v0.4.1:新增 CK 有效性检查并修复抢购调度
This commit is contained in:
+5
-2
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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(¬Found, 1)
|
||||
}
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := atomic.LoadInt32(¬Found); 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
@@ -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 在未命中时把类目限制写进提示,便于区分「被类目过滤掉」与「列表里确实没有」。
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user