v0.4.1:新增 CK 有效性检查并修复抢购调度

This commit is contained in:
yml2213
2026-10-17 14:24:32 +08:00
parent 8b3b14654f
commit 2451466bed
13 changed files with 1210 additions and 132 deletions
+5 -2
View File
@@ -315,7 +315,7 @@ func (a *App) DefaultConfig() Config {
SharePrizeList: true,
AutoSelect: false,
RefreshAfterSuccess: true,
LeadMS: 2500,
LeadMS: 0,
TimeSync: true,
FrequentBackoffMS: 300,
ErrorBackoffMS: 300,
@@ -853,9 +853,12 @@ func parseAccounts(cfg Config) ([]sniper.Account, error) {
return nil, errors.New("Cookie 不能为空")
}
selected := selectedLineSet(cfg.SelectedAccountLines)
if len(selected) == 0 {
return nil, errors.New("未选择账号")
}
accounts := make([]sniper.Account, 0, len(lines))
for _, cookie := range lines {
if len(selected) > 0 && !selected[cookie.lineNo] {
if !selected[cookie.lineNo] {
continue
}
uid := huya.ResolveUID(cookie.text)
+24
View File
@@ -50,6 +50,30 @@ func TestSplitCookieLinesNormalizesLineBreaks(t *testing.T) {
}
}
func TestParseAccountsRequiresExplicitSelection(t *testing.T) {
cfg := Config{
CookieText: "udb_uid=1; yyuid=1\nudb_uid=2; yyuid=2",
}
if _, err := parseAccounts(cfg); err == nil {
t.Fatal("空选择不应回退为全部账号")
}
cfg.SelectedAccountLines = []int{2}
accounts, err := parseAccounts(cfg)
if err != nil {
t.Fatalf("parseAccounts() error = %v", err)
}
if len(accounts) != 1 || accounts[0].UID != 2 {
t.Fatalf("accounts=%+v, want 仅第 2 行账号", accounts)
}
}
func TestDefaultConfigUsesDynamicLead(t *testing.T) {
if got := (&App{}).DefaultConfig().LeadMS; got != 0 {
t.Fatalf("LeadMS=%d, want 0(动态提前量)", got)
}
}
func TestParseStartTimeAcceptsClockOnly(t *testing.T) {
t.Run("future_today", func(t *testing.T) {
now := time.Date(2026, 7, 6, 10, 20, 30, 0, time.Local)
+185
View File
@@ -0,0 +1,185 @@
package gui
import (
"context"
"errors"
"fmt"
"strconv"
"strings"
"time"
"huya-go/internal/huya"
"huya-go/internal/logger"
"huya-go/internal/sniper"
)
const (
CookieStatusValid = "valid"
CookieStatusExpired = "expired"
CookieStatusUnknown = "unknown"
CookieStatusInvalid = "invalid"
// cookieCheckAttempts 对「失效」结果连续确认:线上偶发「账号未绑定!」后下一轮
// 就恢复,直接判死会把好 CK 清掉;与抢购引擎的 sessionLostLimit 保持一致。
cookieCheckAttempts = 3
cookieCheckRetryDelay = 250 * time.Millisecond
)
// CookieCheckResult 描述一条 CK 的服务端可用性检查结果。
// Status 取值:valid=可用、expired=失效/不可用、unknown=请求异常待确认、invalid=格式无法解析。
type CookieCheckResult struct {
Line int `json:"line"`
UID int64 `json:"uid"`
Status string `json:"status"`
Message string `json:"message,omitempty"`
StatusCode int32 `json:"statusCode,omitempty"`
CheckedAt int64 `json:"checkedAt"`
}
// CheckCookies 用 getUserScore 对每条 CK 做真实登录态校验。
//
// 不依赖「能解析出 yyuid」这种本地格式判断:CK 里的 uid 还在、但登录态已经过期
// 是最常见的失败原因。getUserScore 必须携带有效身份,因此适合作为可用性探针。
func (a *App) CheckCookies(cfg Config) ([]CookieCheckResult, error) {
cfg = normalizeConfig(cfg)
lines := splitCookieLines(cfg.CookieText)
if len(lines) == 0 {
return nil, errors.New("Cookie 不能为空")
}
if cfg.SID <= 0 {
return nil, errors.New("SID 不能为空")
}
client, closeClient, err := a.newClient(cfg)
if err != nil {
return nil, err
}
defer closeClient()
accounts := make([]sniper.Account, len(lines))
for i, line := range lines {
accounts[i] = sniper.Account{UID: huya.ResolveUID(line.text), Cookie: line.text}
}
results := make([]CookieCheckResult, len(lines))
a.runConcurrent(accounts, cookieCheckConcurrency(cfg.Concurrency), func(i int, account sniper.Account) {
results[i] = checkOneCookie(client, lines[i], account, cfg.SID, cfg.TimeoutSec)
})
valid, expired, unknown, invalid := 0, 0, 0, 0
for _, item := range results {
switch item.Status {
case CookieStatusValid:
valid++
case CookieStatusExpired:
expired++
case CookieStatusInvalid:
invalid++
default:
unknown++
}
if item.Status == CookieStatusExpired {
a.logAccount(categoryApp, logger.LevelWarn, strconv.FormatInt(item.UID, 10),
"CK 已失效: %s (status=%d)", item.Message, item.StatusCode)
}
}
a.addLog("info", "CK 检查完成: 总数=%d 可用=%d 失效=%d 检查失败=%d 格式错误=%d",
len(results), valid, expired, unknown, invalid)
return results, nil
}
func checkOneCookie(client huya.ActivityClient, line cookieLine, account sniper.Account, sid int32, timeoutSec int) CookieCheckResult {
result := CookieCheckResult{
Line: line.lineNo,
UID: account.UID,
CheckedAt: time.Now().UnixMilli(),
}
if account.UID <= 0 {
result.Status = CookieStatusInvalid
result.Message = "无法解析 yyuid/udb_uid"
return result
}
for attempt := 0; attempt < cookieCheckAttempts; attempt++ {
ctx, cancel := requestContext(timeoutSec)
resp, err := client.QueryUserScore(ctx, account.UID, account.Cookie, sid)
cancel()
status, message, statusCode := cookieCheckVerdict(resp, err)
result.Status = status
result.Message = message
result.StatusCode = statusCode
result.CheckedAt = time.Now().UnixMilli()
if status != CookieStatusExpired || attempt == cookieCheckAttempts-1 {
return result
}
time.Sleep(cookieCheckRetryDelay)
}
return result
}
// cookieCheckVerdict 只把明确的登录态文案判为失效;限流、网络错误等归为 unknown,
// 避免在服务端繁忙时把一批正常 CK 误标成失效。
func cookieCheckVerdict(resp *huya.GetUserScoreResp, err error) (status, message string, statusCode int32) {
if err != nil {
message = strings.TrimSpace(err.Error())
if errors.Is(err, context.DeadlineExceeded) {
message = "检查超时"
}
if message == "" {
message = "请求失败"
}
return CookieStatusUnknown, message, 0
}
if resp == nil {
return CookieStatusUnknown, "服务端未返回数据", 0
}
msg := strings.TrimSpace(resp.Msg)
if isCookieExpiredMessage(msg) {
if msg == "" {
msg = "登录态已失效"
}
return CookieStatusExpired, msg, resp.Status
}
if resp.Status == 200 {
return CookieStatusValid, "CK 可用", resp.Status
}
if msg == "" {
msg = fmt.Sprintf("服务端返回 status=%d", resp.Status)
}
return CookieStatusUnknown, msg, resp.Status
}
func isCookieExpiredMessage(text string) bool {
text = strings.ToLower(strings.TrimSpace(text))
if text == "" {
return false
}
for _, needle := range []string{
"账号未绑定", "未绑定账号", "未绑定手机", "登录态", "登录失效", "登录过期",
"请先登录", "请登录", "未登录", "重新登录", "会话失效", "会话过期",
"凭证失效", "授权失效", "身份失效", "鉴权失败", "认证失败",
"token 失效", "token失效", "cookie 失效", "cookie失效",
"invalid token", "token expired", "unauthorized", "not logged in", "login expired",
} {
if strings.Contains(text, needle) {
return true
}
}
return false
}
// cookieCheckConcurrency 给检查单独限流:检查不是抢购,没必要跟着 100 线程配置齐射。
func cookieCheckConcurrency(configured int) int {
if configured <= 0 {
configured = 5
}
if configured < 3 {
configured = 3
}
if configured > 10 {
configured = 10
}
return configured
}
+79
View File
@@ -0,0 +1,79 @@
package gui
import (
"context"
"errors"
"testing"
"huya-go/internal/huya"
)
func TestCookieCheckVerdict(t *testing.T) {
tests := []struct {
name string
resp *huya.GetUserScoreResp
err error
wantStatus string
}{
{
name: "valid",
resp: &huya.GetUserScoreResp{Status: 200, Msg: "请求成功"},
wantStatus: CookieStatusValid,
},
{
name: "account_not_bound",
resp: &huya.GetUserScoreResp{Status: 500, Msg: "账号未绑定!"},
wantStatus: CookieStatusExpired,
},
{
name: "login_expired",
resp: &huya.GetUserScoreResp{Status: 500, Msg: "登录态已失效,请重新登录"},
wantStatus: CookieStatusExpired,
},
{
name: "too_frequent_is_unknown",
resp: &huya.GetUserScoreResp{Status: 500, Msg: "活动太火爆了,请稍后重试"},
wantStatus: CookieStatusUnknown,
},
{
name: "timeout_is_unknown",
err: context.DeadlineExceeded,
wantStatus: CookieStatusUnknown,
},
{
name: "nil_response_is_unknown",
wantStatus: CookieStatusUnknown,
},
{
name: "network_error_is_unknown",
err: errors.New("connection reset"),
wantStatus: CookieStatusUnknown,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, _, _ := cookieCheckVerdict(tt.resp, tt.err)
if got != tt.wantStatus {
t.Fatalf("cookieCheckVerdict() status = %q, want %q", got, tt.wantStatus)
}
})
}
}
func TestCookieCheckConcurrency(t *testing.T) {
tests := []struct {
input int
want int
}{
{input: 0, want: 5},
{input: 1, want: 3},
{input: 7, want: 7},
{input: 50, want: 10},
}
for _, tt := range tests {
if got := cookieCheckConcurrency(tt.input); got != tt.want {
t.Fatalf("cookieCheckConcurrency(%d) = %d, want %d", tt.input, got, tt.want)
}
}
}
+328
View File
@@ -134,6 +134,46 @@ func TestThrottleGovernorEscalatesAndRecovers(t *testing.T) {
}
}
// TestPrefireProbeCountBounds 验证探活账号数不会跟着高并发设置无限放大。
func TestPrefireProbeCountBounds(t *testing.T) {
tests := []struct {
configured int
total int
want int
}{
{configured: 0, total: 100, want: 1},
{configured: 2, total: 100, want: 2},
{configured: 8, total: 100, want: 8},
{configured: 100, total: 100, want: 8},
{configured: 5, total: 3, want: 3},
{configured: 5, total: 0, want: 0},
}
for _, tt := range tests {
if got := prefireProbeCount(tt.configured, tt.total); got != tt.want {
t.Fatalf("prefireProbeCount(%d,%d)=%d, want %d", tt.configured, tt.total, got, tt.want)
}
}
}
// TestPrewarmConcurrencyBounds 验证预热并发不会跟着抢购线程设置过低或过高。
func TestPrewarmConcurrencyBounds(t *testing.T) {
tests := []struct {
input int
want int
}{
{input: 0, want: 8},
{input: 1, want: 8},
{input: 5, want: 8},
{input: 12, want: 12},
{input: 100, want: 16},
}
for _, tt := range tests {
if got := prewarmConcurrency(tt.input); got != tt.want {
t.Fatalf("prewarmConcurrency(%d)=%d, want %d", tt.input, got, tt.want)
}
}
}
// TestRunStateFirstWaveStagger 验证首发错峰:第 0 个账号立即发,其余按步长错开,每个账号只生效一次。
func TestRunStateFirstWaveStagger(t *testing.T) {
accounts := []Account{{UID: 1, Cookie: "yyuid=1"}, {UID: 2, Cookie: "yyuid=2"}, {UID: 3, Cookie: "yyuid=3"}}
@@ -153,6 +193,294 @@ func TestRunStateFirstWaveStagger(t *testing.T) {
}
}
// TestRunStateSessionStreakResetIsScopedAndIndependentOfGovernor 验证会话失效计数
// 只按当前账号清理,并且不依赖自适应降速开关。
func TestRunStateSessionStreakResetIsScopedAndIndependentOfGovernor(t *testing.T) {
for _, withGovernor := range []bool{false, true} {
state := newRunState([]Account{{UID: 1}, {UID: 2}}, 1, 1, Config{})
if withGovernor {
state.governor = newThrottleGovernor()
}
state.bumpSessionStreak(1, 0)
state.bumpSessionStreak(1, 0)
// 另一个账号拿到正常业务响应,不能重置账号 1 的连续失效计数。
state.observeThrottle(2, CategorySoldOut)
if got := state.accounts[1][0].SessionStreak; got != 2 {
t.Fatalf("governor=%v: 其他账号不应重置会话失效计数,got=%d", withGovernor, got)
}
// 网络错误 / 协议异常没有可信业务响应,也不能把失效计数洗掉。
state.observeThrottle(1, CategoryError)
state.observeThrottle(1, CategoryProtocol)
if got := state.accounts[1][0].SessionStreak; got != 2 {
t.Fatalf("governor=%v: 网络/协议错误不应重置会话失效计数,got=%d", withGovernor, got)
}
// 账号 1 自己拿到正常业务响应后必须清零,即使降速器关闭。
state.observeThrottle(1, CategorySoldOut)
if got := state.accounts[1][0].SessionStreak; got != 0 {
t.Fatalf("governor=%v: 本账号恢复后应清零,got=%d", withGovernor, got)
}
}
}
// TestRunTargetsWaitsForWindowWithoutPrefire 验证即使不需要预打,也不会提前进入窗口循环。
func TestRunTargetsWaitsForWindowWithoutPrefire(t *testing.T) {
var mu sync.Mutex
var first time.Time
client := &fakeActivityClient{
exchangeFn: func(uid int64, sid, pid int32) (*huya.ScoreExchangePrizeResp, error) {
mu.Lock()
if first.IsZero() {
first = time.Now()
}
mu.Unlock()
return &huya.ScoreExchangePrizeResp{Status: 500, Msg: "活动太火爆了,请稍后重试"}, nil
},
}
openAt := time.Now().Add(300 * time.Millisecond)
err := (&Runner{Client: client}).RunTargets(context.Background(), []Account{{UID: 1, Cookie: "yyuid=1"}}, []Target{{PID: 1}}, Config{
SID: 2203,
OpenAt: openAt,
windowOverride: 20 * time.Millisecond,
Loops: 1,
Delay: time.Millisecond,
StartAhead: 100 * time.Millisecond,
ErrorBackoff: time.Millisecond,
TooFrequentBackoff: time.Millisecond,
}, nil)
if err != nil {
t.Fatal(err)
}
mu.Lock()
got := first
mu.Unlock()
windowStart := openAt.Add(-100 * time.Millisecond)
if got.Before(windowStart.Add(-10 * time.Millisecond)) {
t.Fatalf("首次请求=%v, 早于窗口起点 %v", got, windowStart)
}
}
// TestRunTargetsStopAccountAfterSuccessStopsAllTargets 验证「账号成功停」是账号级开关:
// 成功一个商品后,同一账号不应继续兑换剩余目标。
func TestRunTargetsStopAccountAfterSuccessStopsAllTargets(t *testing.T) {
client := &fakeActivityClient{}
runner := Runner{Client: client}
err := runner.RunTargets(context.Background(), []Account{{UID: 1, Cookie: "yyuid=1"}}, []Target{
{PID: 1},
{PID: 2},
}, Config{
SID: 2203,
Loops: 2,
Delay: time.Millisecond,
StopAccountAfterSuccess: true,
}, nil)
if err != nil {
t.Fatal(err)
}
if _, exchangeCount, _ := client.counts(); exchangeCount != 1 {
t.Fatalf("exchangeCount=%d, want 1(账号成功后应停止全部目标)", exchangeCount)
}
}
// TestRunTargetsSessionLostStopsWholeAccount 验证会话连续失效达到阈值后停止整个账号,
// 而不是只停当前目标。
func TestRunTargetsSessionLostStopsWholeAccount(t *testing.T) {
client := &fakeActivityClient{
exchangeFn: func(uid int64, sid, pid int32) (*huya.ScoreExchangePrizeResp, error) {
return &huya.ScoreExchangePrizeResp{Status: 500, Msg: "账号未绑定!"}, nil
},
}
runner := Runner{Client: client}
err := runner.RunTargets(context.Background(), []Account{{UID: 1, Cookie: "yyuid=1"}}, []Target{
{PID: 1},
{PID: 2},
}, Config{
SID: 2203,
Loops: 10,
Delay: 5 * time.Millisecond,
ErrorBackoff: time.Millisecond,
SessionLostLimit: 3,
}, nil)
if err != nil {
t.Fatal(err)
}
// 第 1、2 轮各打两个目标;第 3 轮第一个目标连续第 3 次失效后整账号停止。
if _, exchangeCount, _ := client.counts(); exchangeCount != 5 {
t.Fatalf("exchangeCount=%d, want 5(达到阈值后应停止整个账号)", exchangeCount)
}
}
// TestRunStateElapsedUsesOpenAt 验证退避阶段从开抢时刻起算,而不是从提前启动时起算。
func TestRunStateElapsedUsesOpenAt(t *testing.T) {
state := &runState{
startedAt: time.Now().Add(-10 * time.Second),
openAt: time.Now().Add(-2 * time.Second),
}
if got := state.elapsed(); got < 1900*time.Millisecond || got > 3*time.Second {
t.Fatalf("elapsed=%v, want 约 2s(按 openAt 计算)", got)
}
}
// TestRunTargetsNotFoundBacksOff 验证未命中时不会每轮刷事件和列表请求。
func TestRunTargetsNotFoundBacksOff(t *testing.T) {
client := &fakeActivityClient{listResp: &huya.GetActPrizeListResp{Status: 200}}
runner := Runner{Client: client}
var notFound int32
err := runner.RunTargets(context.Background(), []Account{{UID: 1, Cookie: "yyuid=1"}}, []Target{
{Name: "不存在的奖品"},
}, Config{
SID: 2203,
Loops: 6,
Delay: time.Millisecond,
ErrorBackoff: 25 * time.Millisecond,
ListBeforeExchange: true,
}, func(result Result) {
if result.Category == CategoryNotFound {
atomic.AddInt32(&notFound, 1)
}
})
if err != nil {
t.Fatal(err)
}
if got := atomic.LoadInt32(&notFound); got != 1 {
t.Fatalf("not_found 事件=%d, want 1(退避期间应跳过)", got)
}
}
// TestRunTargetsNotOpenBacksOff 验证未开放时也会退避,不会以 Delay 持续轰接口。
func TestRunTargetsNotOpenBacksOff(t *testing.T) {
client := &fakeActivityClient{
exchangeFn: func(uid int64, sid, pid int32) (*huya.ScoreExchangePrizeResp, error) {
return &huya.ScoreExchangePrizeResp{Status: 500, Msg: "奖品暂未开放兑换"}, nil
},
}
runner := Runner{Client: client}
err := runner.RunTargets(context.Background(), []Account{{UID: 1, Cookie: "yyuid=1"}}, []Target{
{PID: 1},
}, Config{
SID: 2203,
Loops: 6,
Delay: time.Millisecond,
ErrorBackoff: 25 * time.Millisecond,
}, nil)
if err != nil {
t.Fatal(err)
}
if _, exchangeCount, _ := client.counts(); exchangeCount != 1 {
t.Fatalf("exchangeCount=%d, want 1(未开放应退避)", exchangeCount)
}
}
// TestExchangeTargetSkipsAfterWindow 验证排队拿到并发额度时窗口已结束,
// 不会把兑换请求补发到窗口外。
func TestExchangeTargetSkipsAfterWindow(t *testing.T) {
client := &fakeActivityClient{}
account := Account{UID: 1, Cookie: "yyuid=1"}
state := newRunState([]Account{account}, 1, 1, Config{
OpenAt: time.Now().Add(-2 * time.Second),
WindowSeconds: 1,
})
result := (&Runner{Client: client}).exchangeTarget(
context.Background(), client, state, account, Target{PID: 1}, 0, 1, 2203, nil,
)
if result.Action != actionExchangeCanceled {
t.Fatalf("action=%q, want %q", result.Action, actionExchangeCanceled)
}
if _, exchangeCount, _ := client.counts(); exchangeCount != 0 {
t.Fatalf("exchangeCount=%d, want 0(窗口外不能补发)", exchangeCount)
}
}
// TestRunTargetsDirectExchangeHonorsPriceFilter 验证设置价格门槛后不能走直兑绕过过滤。
func TestRunTargetsDirectExchangeHonorsPriceFilter(t *testing.T) {
client := &fakeActivityClient{
listResp: &huya.GetActPrizeListResp{
Status: 200,
Prizes: []huya.PrizeInfo{{ID: 1, Name: "涨价商品", NewScore: 100}},
},
}
err := (&Runner{Client: client}).RunTargets(context.Background(), []Account{{UID: 1, Cookie: "yyuid=1"}}, []Target{
{PID: 1, MaxPrice: 50},
}, Config{
SID: 2203,
Loops: 1,
Delay: time.Millisecond,
DirectExchange: true,
ListBeforeExchange: false,
}, nil)
if err != nil {
t.Fatal(err)
}
listCount, exchangeCount, _ := client.counts()
if listCount != 1 || exchangeCount != 0 {
t.Fatalf("list=%d exchange=%d, want list=1 exchange=0(价格超限不能直兑)", listCount, exchangeCount)
}
}
// TestRunTargetsPrefireProbeIsBounded 验证预打探活最多只用一个并发批次,
// 不会在账号很多时把请求拖到开抢之后。
func TestRunTargetsPrefireProbeIsBounded(t *testing.T) {
var mu sync.Mutex
calls := make([]time.Time, 0, 8)
client := &fakeActivityClient{
exchangeFn: func(uid int64, sid, pid int32) (*huya.ScoreExchangePrizeResp, error) {
mu.Lock()
calls = append(calls, time.Now())
mu.Unlock()
return &huya.ScoreExchangePrizeResp{Status: 500, Msg: "奖品暂未开放兑换"}, nil
},
}
accounts := make([]Account, 0, 6)
for uid := int64(1); uid <= 6; uid++ {
accounts = append(accounts, Account{UID: uid, Cookie: "yyuid=1"})
}
openAt := time.Now().Add(350 * time.Millisecond)
err := (&Runner{Client: client}).RunTargets(context.Background(), accounts, []Target{{PID: 1}}, Config{
SID: 2203,
OpenAt: openAt,
windowOverride: 30 * time.Millisecond,
Loops: 1,
Delay: time.Millisecond,
StartAhead: 20 * time.Millisecond,
Concurrency: 2,
ErrorBackoff: time.Millisecond,
TooFrequentBackoff: time.Millisecond,
}, nil)
if err != nil {
t.Fatal(err)
}
windowStart := openAt.Add(-20 * time.Millisecond)
mu.Lock()
defer mu.Unlock()
prefire := 0
for _, at := range calls {
if at.Before(windowStart) {
prefire++
}
}
if prefire > 2 {
t.Fatalf("预打请求=%d, want <= 2(仅一个并发批次)", prefire)
}
}
// TestRetryDelayNeverExceedsCap 验证全局降速和抖动不能把单次退避放大到上限之外。
func TestRetryDelayNeverExceedsCap(t *testing.T) {
state := newRunState([]Account{{UID: 1}}, 1, 1, Config{})
state.governor = newThrottleGovernor()
state.governor.factor = governorMaxFactor
for i := 0; i < 20; i++ {
got := state.retryDelay(1, 0, Config{
ErrorBackoff: 300 * time.Millisecond,
TooFrequentBackoff: 300 * time.Millisecond,
}, CategoryTooFrequent)
if got > maxRetryDelay {
t.Fatalf("retryDelay=%v, want <= %v", got, maxRetryDelay)
}
}
}
// TestRunTargetsWindowModeKeepsTryingUntilDeadline 是 P1 的核心回归:
// 账号很少时,旧实现会「20 轮 × 150ms」在开抢前把预算烧光(pc-3 instance-4 0 成功),
// 窗口模式必须一直打到窗口结束。
+163 -42
View File
@@ -464,9 +464,9 @@ func (r *Runner) RunTargets(ctx context.Context, accounts []Account, targets []T
r.emitSummary(state, len(accounts), len(targets), state.maxRound(), time.Since(startedAt))
}()
runWave := func(loop int) {
runWave := func(loop int, waveAccounts []Account) {
var wg sync.WaitGroup
for _, account := range accounts {
for _, account := range waveAccounts {
account := account
wg.Add(1)
go func() {
@@ -484,12 +484,23 @@ func (r *Runner) RunTargets(ctx context.Context, accounts []Account, targets []T
// 2026-10-16 pc-1 实测 1421 次请求里 82% 被限流挡回。
if state.needsPrefire() {
state.markPrefire()
runWave(1)
// 预打只需要探活,不需要把所有账号都打一遍:账号多且网络慢时,
// 全账号预打可能一直打到开抢之后,反而阻塞正式窗口。
probeAccounts := accounts
if limit := prefireProbeCount(cfg.Concurrency, len(probeAccounts)); limit < len(probeAccounts) {
probeAccounts = probeAccounts[:limit]
}
runWave(1, probeAccounts)
if ctx.Err() != nil {
return ctx.Err()
}
if !state.windowExpired() {
if err := sleepContext(ctx, time.Until(state.windowStart())); err != nil {
}
// 无论是否预打,正式请求都不能早于「开抢 − StartAhead」。
// 非预打分支过去直接进入循环,固定提前量在 250~310ms 时会产生窗口外请求。
if !state.windowed() || !state.windowExpired() {
if wait := time.Until(state.windowStart()); wait > 0 {
if err := sleepContext(ctx, wait); err != nil {
return err
}
}
@@ -525,7 +536,7 @@ func (r *Runner) Prewarm(ctx context.Context, accounts []Account, cfg Config, em
if !ok {
return nil
}
sem := make(chan struct{}, cfg.Concurrency)
sem := make(chan struct{}, prewarmConcurrency(cfg.Concurrency))
var wg sync.WaitGroup
for _, account := range accounts {
account := account
@@ -583,7 +594,8 @@ func (r *Runner) runAccountLoop(ctx context.Context, client huya.ActivityClient,
}
state.noteRound(round)
r.runAccountRound(ctx, client, state, account, targets, cfg, round, emit, cancel)
if ctx.Err() != nil || state.allDone() || state.windowExpired() {
if ctx.Err() != nil || state.allDone() || state.windowExpired() ||
state.accountFinished(account.UID, len(targets)) {
return
}
// 本账号自己的节奏:固定等 cfg.Delay。退避中的目标会在下一轮被 activeTargets 跳过,
@@ -624,7 +636,7 @@ func (r *Runner) runAccountRound(ctx context.Context, client huya.ActivityClient
emit(result)
}
r.refreshAfterSuccess(state, client, account, target, index, loop, cfg, result, emit)
if ctx.Err() != nil {
if ctx.Err() != nil || state.accountFinished(account.UID, len(targets)) {
return
}
continue
@@ -638,6 +650,10 @@ func (r *Runner) runAccountRound(ctx context.Context, client huya.ActivityClient
// SharePrizeList 打开时,多账号复用同一份列表快照(带 TTL 的单飞缓存),
// 避免每个账号每一轮都各查一次列表。
list := r.listForAccount(ctx, client, account, cfg, state)
if ctx.Err() != nil || state.windowExpired() {
// 停止任务或窗口结束时,不要为每个目标补一条 list_error。
return
}
if list.err != nil || list.resp == nil {
errText := "奖品列表响应为空"
if list.err != nil {
@@ -672,6 +688,7 @@ func (r *Runner) runAccountRound(ctx context.Context, client huya.ActivityClient
prize := matchPrize(prizes, target)
if prize == nil {
state.recordOutcome(CategoryNotFound)
retryAt := state.scheduleRetry(account.UID, index, cfg, CategoryNotFound)
result := Result{
Loop: loop,
UID: account.UID,
@@ -680,6 +697,7 @@ func (r *Runner) runAccountRound(ctx context.Context, client huya.ActivityClient
Action: "not_found",
Category: CategoryNotFound,
Message: notFoundMessage(cfg.Category),
RetryAfter: retryAt,
}
if emit != nil {
emit(result)
@@ -703,7 +721,7 @@ func (r *Runner) runAccountRound(ctx context.Context, client huya.ActivityClient
emit(result)
}
r.refreshAfterSuccess(state, client, account, target, index, loop, cfg, result, emit)
if ctx.Err() != nil {
if ctx.Err() != nil || state.accountFinished(account.UID, len(targets)) {
return
}
}
@@ -765,6 +783,14 @@ func (r *Runner) exchangeTarget(ctx context.Context, client huya.ActivityClient,
result.Error = ctx.Err().Error()
return result
}
// 排队等额度期间窗口可能已经结束,不能把请求补发到窗口外。
if state.windowExpired() {
state.release()
result.Action = actionExchangeCanceled
result.Category = CategoryError
result.Message = "窗口已结束,未发起兑换"
return result
}
started := time.Now()
exchange, err := client.ScoreExchangePrize(ctx, account.UID, account.Cookie, sid, pid)
state.release()
@@ -784,15 +810,17 @@ func (r *Runner) exchangeTarget(ctx context.Context, client huya.ActivityClient,
func (r *Runner) applyExchangeDecision(state *runState, account Account, index int, cfg Config, result Result, cancel context.CancelFunc) Result {
state.recordOutcome(result.Category)
state.observeThrottle(result.Category)
state.observeThrottle(account.UID, result.Category)
if result.Category == CategorySuccess {
state.markSuccessUID(account.UID)
}
switch result.Category {
case CategorySuccess:
if cfg.StopAccountAfterSuccess {
state.markDone(account.UID, index)
state.markAccountDone(account.UID)
result.Done = true
} else {
state.markDone(account.UID, index)
}
if cfg.StopAfterSuccess {
cancel()
@@ -802,27 +830,32 @@ func (r *Runner) applyExchangeDecision(state *runState, account Account, index i
state.markDone(account.UID, index)
result.Done = true
}
// 未开启「积分不足即停」时也要退避,避免每轮都重复撞同一个终态。
if !result.Done {
result.RetryAfter = state.scheduleRetry(account.UID, index, cfg, result.Category)
}
case CategoryOffShelf:
// 已下架 / 奖品不存在:本窗口内不会再出现,直接终止该 target。
state.markTargetDone(index)
result.Done = true
case CategorySessionLost:
// 会话失效实测是瞬时的(下一轮即可成功),所以先照常重试;
// 只有连续多次才停止该账号,避免真的失效后白打一整个窗口的请求。
// 只有连续多次才停止整个账号,避免无效 CK 把其他目标也打满整个窗口。
streak := state.bumpSessionStreak(account.UID, index)
if limit := sessionLostLimit(cfg); streak >= limit {
state.markDone(account.UID, index)
state.markAccountDone(account.UID)
result.Done = true
result.Message = fmt.Sprintf("会话连续失效 %d 次,停止该账号", streak)
} else {
result.RetryAfter = state.scheduleRetry(account.UID, index, cfg, result.Category)
}
case CategorySoldOut:
if cfg.StopOnSoldOut {
case CategorySoldOut, CategoryNotOpen:
if result.Category == CategorySoldOut && cfg.StopOnSoldOut {
state.markTargetDone(index)
result.Done = true
} else {
// 别人锁单未支付或取消会让库存回流,窗口内继续探测(只是放慢节奏)。
// 售罄可能回流;未开放通常只是还没到点。两者都继续等待,但必须退避,
// 否则窗口内会以配置的 Delay 持续轰同一个接口。
result.RetryAfter = state.scheduleRetry(account.UID, index, cfg, result.Category)
}
case CategoryTooFrequent:
@@ -869,8 +902,13 @@ func (s *runState) scheduleRetry(uid int64, index int, cfg Config, category stri
// 6. 任何一次等待都不超过 maxRetryDelay——超过 1.5 秒就可能正好错过回流库存。
func (s *runState) retryDelay(uid int64, index int, cfg Config, category string) time.Duration {
base := cfg.ErrorBackoff
if category == CategoryTooFrequent {
switch category {
case CategoryTooFrequent:
base = cfg.TooFrequentBackoff
case CategoryNotOpen:
// 开抢边沿的首个请求可能只早了十几毫秒,不能用 300ms 直接错过先手;
// 先按账号节奏快速重试,连续未开放再逐级放大。
base = maxDuration(cfg.Delay, 50*time.Millisecond)
}
if base <= 0 {
base = defaultRetryBackoff
@@ -886,11 +924,26 @@ func (s *runState) retryDelay(uid int64, index int, cfg Config, category string)
if factor := s.throttleFactor(); factor > 1 {
delay = time.Duration(float64(delay) * factor)
}
return jitterDuration(delay)
// 全局降速倍率和抖动必须在最后再裁剪,否则 1.5s 的上限会被放大到 6~7s,
// 正好错过库存回流窗口。
delay = jitterDuration(delay)
if delay > maxRetryDelay {
delay = maxRetryDelay
}
return delay
}
// elapsed 返回任务开始至今的时长,用于按阶段取退避节奏。
// elapsed 返回相对开抢时刻的已用时,用于按阶段取退避节奏。
// 定时模式可能在开抢前数秒就启动(预打/等待),如果按 startedAt 计算,
// 窗口一开始就已经进入「后段降速」,会白白牺牲开抢头几秒。
func (s *runState) elapsed() time.Duration {
if !s.openAt.IsZero() {
elapsed := time.Since(s.openAt)
if elapsed < 0 {
return 0
}
return elapsed
}
if s.startedAt.IsZero() {
return 0
}
@@ -919,7 +972,7 @@ func stageMultiplier(elapsed time.Duration, category string) int {
// escalatingCategory 返回该分类是否参与「连续失败翻倍」的统计。
func escalatingCategory(category string) bool {
switch category {
case CategoryFailed, CategoryTooFrequent, CategoryError, CategoryProtocol, CategorySessionLost, CategoryCondition:
case CategoryFailed, CategoryTooFrequent, CategoryError, CategoryProtocol, CategorySessionLost, CategoryCondition, CategoryNotOpen:
return true
default:
return false
@@ -973,36 +1026,48 @@ func (s *runState) bumpSessionStreak(uid int64, index int) int {
return streak
}
// observeThrottle 把结局交给全局降速器。会话失效等其它结局会重置「无进展」计数。
func (s *runState) observeThrottle(category string) {
if s.governor == nil {
return
// observeThrottle 把结局交给全局降速器。只有明确拿到业务响应时才清空当前账号的
// 会话失效连续计数;限流与网络错误不能证明会话有效。
func (s *runState) observeThrottle(uid int64, category string) {
if sessionAliveCategory(category) {
s.clearSessionStreak(uid)
}
if category != CategoryTooFrequent {
s.clearSessionStreak(category)
if s.governor != nil {
s.governor.observe(category)
}
s.governor.observe(category)
}
// clearSessionStreak 在拿到任何非会话失效结局后清空连续失效计数。
func (s *runState) clearSessionStreak(category string) {
if category == CategorySessionLost {
return
// sessionAliveCategory 返回该结局是否能证明当前账号的登录态仍然有效。
// 网络错误、协议异常和限流都不算:它们没有拿到可信的业务响应。
func sessionAliveCategory(category string) bool {
switch category {
case CategorySuccess, CategoryNotOpen, CategorySoldOut, CategoryNotEnough,
CategoryAlreadyDone, CategoryOffShelf, CategoryCondition, CategoryFailed:
return true
default:
return false
}
}
// clearSessionStreak 在某个账号拿到非会话失效结局后,清空该账号的连续失效计数。
//
// 必须按账号清理,不能全局清理:多账号同时抢购时,其他账号的成功会不断把
// 一个无效 CK 的 session_lost 计数归零,导致它永远达不到停止阈值。
// 同理,这段逻辑不能依赖自适应降速器是否开启。
func (s *runState) clearSessionStreak(uid int64) {
s.mu.Lock()
defer s.mu.Unlock()
for uid, items := range s.accounts {
changed := false
for index := range items {
if items[index].SessionStreak != 0 {
items[index].SessionStreak = 0
changed = true
}
}
if changed {
s.accounts[uid] = items
items := s.accounts[uid]
changed := false
for index := range items {
if items[index].SessionStreak != 0 {
items[index].SessionStreak = 0
changed = true
}
}
if changed {
s.accounts[uid] = items
}
}
// throttleFactor 返回当前的自适应降速倍率(未启用时恒为 1)。
@@ -1170,6 +1235,10 @@ func (r *Runner) listForAccount(ctx context.Context, client huya.ActivityClient,
if !state.acquire(ctx) {
return &listSnapshot{err: ctx.Err()}
}
if state.windowExpired() {
state.release()
return &listSnapshot{err: errors.New("窗口已结束")}
}
started := time.Now()
resp, err := client.GetActPrizeList(ctx, account.UID, account.Cookie, cfg.SID)
state.release()
@@ -1189,6 +1258,37 @@ func (r *Runner) client() huya.ActivityClient {
return huya.NewHTTPClient(nil)
}
// prefireProbeCount 限制开抢前探活账号数:探活只需要少量样本,
// 即使抢购并发设到 100,也不能在开抢前齐射一百个请求。
func prefireProbeCount(configured, total int) int {
if total <= 0 {
return 0
}
if configured <= 0 {
configured = 1
}
if configured > 8 {
configured = 8
}
if configured > total {
return total
}
return configured
}
// prewarmConcurrency 给建连预热单独限流:抢购请求仍然严格按 Concurrency,
// 但预热必须在开抢前 2 秒内完成。沿用 5 个并发时,几十上百个账号很容易
// 预热到开抢之后才返回,反而错过整个窗口。
func prewarmConcurrency(configured int) int {
if configured < 8 {
configured = 8
}
if configured > 16 {
configured = 16
}
return configured
}
func newRunState(accounts []Account, targetCount, concurrency int, cfg Config) *runState {
if concurrency <= 0 {
concurrency = 1
@@ -1658,6 +1758,20 @@ func (s *runState) markDone(uid int64, index int) {
}
}
// markAccountDone 一次性结束该账号的所有目标。
// 「账号成功停」和会话连续失效都是账号级终态;只停当前 target 会让同一账号
// 继续打其他奖品,既违背开关语义,也可能造成重复扣分。
func (s *runState) markAccountDone(uid int64) {
s.mu.Lock()
defer s.mu.Unlock()
items := s.accounts[uid]
for index := range items {
items[index].Done = true
items[index].RetryAfter = time.Time{}
}
s.accounts[uid] = items
}
func (s *runState) markTargetDone(index int) {
s.mu.Lock()
defer s.mu.Unlock()
@@ -1763,7 +1877,14 @@ func normalizeTargets(targets []Target) []Target {
}
func shouldDirectExchange(target Target, cfg Config) bool {
return cfg.DirectExchange && !cfg.ListBeforeExchange && target.PID > 0 && !target.Auto
// 设置了价格/库存门槛时必须先查列表,否则直兑会绕过过滤条件,
// 商品临时涨价或库存不足时仍会直接下单。
return cfg.DirectExchange &&
!cfg.ListBeforeExchange &&
target.PID > 0 &&
!target.Auto &&
target.MaxPrice <= 0 &&
target.MinLeft <= 0
}
// notFoundMessage 在未命中时把类目限制写进提示,便于区分「被类目过滤掉」与「列表里确实没有」。
+3 -3
View File
@@ -5,10 +5,10 @@ package version
//
// 构建时可用 ldflags 覆盖(构建脚本就是这么做的):
//
// go build -ldflags "-X huya-go/internal/version.Version=0.4.0"
var Version = "0.4.0"
// go build -ldflags "-X huya-go/internal/version.Version=0.4.1"
var Version = "0.4.1"
// Display 返回带 v 前缀的展示版本号,例如 v0.4.0。
// Display 返回带 v 前缀的展示版本号,例如 v0.4.1。
func Display() string {
return "v" + Version
}