547 lines
17 KiB
Go
547 lines
17 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"mime/multipart"
|
|
"net/http"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// NewDouyuClient 创建一个专门请求斗鱼接口的客户端。
|
|
func NewDouyuClient(timeAPIURL string, trace *traceRecorder) *DouyuClient {
|
|
return &DouyuClient{
|
|
timeAPIURL: timeAPIURL,
|
|
trace: trace,
|
|
httpClient: &http.Client{
|
|
Timeout: 8 * time.Second,
|
|
Transport: &http.Transport{
|
|
MaxConnsPerHost: 120,
|
|
MaxIdleConns: 120,
|
|
MaxIdleConnsPerHost: 80,
|
|
IdleConnTimeout: 30 * time.Second,
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// ServerTime 从商品详情接口读取 data.preExchange.currentTime。
|
|
func (c *DouyuClient) ServerTime() (time.Time, error) {
|
|
sample, err := c.ServerTimeSample()
|
|
return sample.EstimatedServerNow(), err
|
|
}
|
|
|
|
// ServerTimeSample 从斗鱼秒级 currentTime 估算毫秒级服务端时间。
|
|
func (c *DouyuClient) ServerTimeSample() (TimeSample, error) {
|
|
var lastErr error
|
|
for i := 0; i < 3; i++ {
|
|
sample, err := c.fetchServerTimeOnce()
|
|
if err == nil {
|
|
sample.Samples = 1
|
|
sample.Source = "single"
|
|
return sample, nil
|
|
}
|
|
lastErr = err
|
|
time.Sleep(100 * time.Millisecond)
|
|
}
|
|
now := time.Now()
|
|
return TimeSample{
|
|
ServerTime: now.UTC(),
|
|
LocalTime: now,
|
|
Offset: 0,
|
|
Source: "localFallback",
|
|
Fallback: true,
|
|
}, fmt.Errorf("服务端时间获取失败，已降级本地时间: %w", lastErr)
|
|
}
|
|
|
|
// CalibratedServerTimeSample 通过等待 currentTime 跳秒估算本地与斗鱼秒边界的偏移。
|
|
func (c *DouyuClient) CalibratedServerTimeSample(maxWait time.Duration) (TimeSample, error) {
|
|
first, err := c.ServerTimeSample()
|
|
if err != nil || maxWait <= 0 {
|
|
return first, err
|
|
}
|
|
|
|
deadline := time.Now().Add(maxWait)
|
|
prev := first
|
|
for time.Now().Before(deadline) {
|
|
time.Sleep(40 * time.Millisecond)
|
|
current, err := c.fetchServerTimeOnce()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if current.RawCurrentTime <= prev.RawCurrentTime {
|
|
prev = current
|
|
continue
|
|
}
|
|
|
|
sampleGap := current.LocalTime.Sub(prev.LocalTime)
|
|
localBoundary := prev.LocalTime.Add(sampleGap / 2)
|
|
serverBoundary := time.Unix(current.RawCurrentTime, 0).UTC()
|
|
offset := serverBoundary.Sub(localBoundary.UTC())
|
|
current.Offset = offset
|
|
current.ServerTime = current.EstimatedServerNow()
|
|
current.LocalTime = time.Now()
|
|
current.RTT += first.RTT
|
|
current.ErrorBound = sampleGap / 2
|
|
current.Samples = 2
|
|
current.Source = "boundary"
|
|
return current, nil
|
|
}
|
|
|
|
first.ServerTime = first.EstimatedServerNow()
|
|
return first, nil
|
|
}
|
|
|
|
// BestServerTimeCalibration 多次校准，选择误差范围最小、RTT更低的一次。
|
|
func (c *DouyuClient) BestServerTimeCalibration(rounds int, maxWait time.Duration) (TimeCalibration, error) {
|
|
if rounds <= 0 {
|
|
rounds = 1
|
|
}
|
|
var best TimeSample
|
|
var lastErr error
|
|
for i := 0; i < rounds; i++ {
|
|
sample, err := c.CalibratedServerTimeSample(maxWait)
|
|
if err != nil {
|
|
lastErr = err
|
|
}
|
|
if sample.LocalTime.IsZero() {
|
|
continue
|
|
}
|
|
sample.Samples = max(sample.Samples, 1)
|
|
if best.LocalTime.IsZero() || betterTimeSample(sample, best) {
|
|
best = sample
|
|
}
|
|
}
|
|
if best.LocalTime.IsZero() {
|
|
now := time.Now()
|
|
return TimeCalibration{
|
|
CreatedAt: now,
|
|
Source: "localFallback",
|
|
Fallback: true,
|
|
}, fmt.Errorf("斗鱼时间校准失败: %w", lastErr)
|
|
}
|
|
return TimeCalibration{
|
|
Offset: best.Offset,
|
|
ErrorBound: best.ErrorBound,
|
|
RTT: best.RTT,
|
|
Samples: rounds,
|
|
CreatedAt: time.Now(),
|
|
Source: best.Source,
|
|
Fallback: best.Fallback,
|
|
}, lastErr
|
|
}
|
|
|
|
func betterTimeSample(candidate, current TimeSample) bool {
|
|
if candidate.ErrorBound != 0 && current.ErrorBound == 0 {
|
|
return true
|
|
}
|
|
if candidate.ErrorBound == 0 && current.ErrorBound != 0 {
|
|
return false
|
|
}
|
|
if candidate.ErrorBound != current.ErrorBound {
|
|
return candidate.ErrorBound < current.ErrorBound
|
|
}
|
|
return candidate.RTT < current.RTT
|
|
}
|
|
|
|
// fetchServerTimeOnce 执行一次服务端时间请求。
|
|
func (c *DouyuClient) fetchServerTimeOnce() (TimeSample, error) {
|
|
url := appendCacheBuster(c.timeAPIURL)
|
|
var result struct {
|
|
APIResponse
|
|
Data struct {
|
|
PreExchange struct {
|
|
CurrentTime string `json:"currentTime"`
|
|
} `json:"preExchange"`
|
|
} `json:"data"`
|
|
}
|
|
start := time.Now()
|
|
if err := c.getJSON(url, "", "服务时间", &result); err != nil {
|
|
return TimeSample{}, err
|
|
}
|
|
end := time.Now()
|
|
ts, err := strconv.ParseInt(result.Data.PreExchange.CurrentTime, 10, 64)
|
|
if err != nil || ts <= 0 {
|
|
return TimeSample{}, fmt.Errorf("currentTime 无效: %q", result.Data.PreExchange.CurrentTime)
|
|
}
|
|
rtt := end.Sub(start)
|
|
|
|
// 斗鱼 currentTime 只有秒级；用响应到达时本地时钟的毫秒部分补齐，避免定时提前量被秒级截断吃掉。
|
|
estimatedLocal := start.Add(rtt / 2)
|
|
serverTime := time.Unix(ts, 0).Add(time.Duration(estimatedLocal.Nanosecond())).UTC()
|
|
return TimeSample{
|
|
ServerTime: serverTime,
|
|
LocalTime: estimatedLocal,
|
|
RTT: rtt,
|
|
Offset: serverTime.Sub(estimatedLocal.UTC()),
|
|
RawCurrentTime: ts,
|
|
}, nil
|
|
}
|
|
|
|
// Products 拉取商城商品列表。
|
|
func (c *DouyuClient) Products() ([]Product, error) {
|
|
var result struct {
|
|
APIResponse
|
|
Data struct {
|
|
List []Product `json:"list"`
|
|
} `json:"data"`
|
|
}
|
|
if err := c.getJSON(storeHomeURL, "", "商品列表", &result); err != nil {
|
|
return nil, err
|
|
}
|
|
if result.Error != 0 {
|
|
return nil, fmt.Errorf("商品接口失败: %s", result.Msg)
|
|
}
|
|
return result.Data.List, nil
|
|
}
|
|
|
|
// Score 查询账号积分余额。
|
|
func (c *DouyuClient) Score(cookie string) (int, error) {
|
|
req, err := http.NewRequest("POST", scoreURL, strings.NewReader(`{}`))
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
c.setJSONHeaders(req, cookie)
|
|
req.Header.Set("Referer", baseURL+"/")
|
|
|
|
var result struct {
|
|
APIResponse
|
|
Data struct {
|
|
Balance int `json:"balance"`
|
|
} `json:"data"`
|
|
}
|
|
if err := c.doJSON(req, &result, "积分余额"); err != nil {
|
|
return 0, err
|
|
}
|
|
if result.Error != 0 {
|
|
return 0, fmt.Errorf("积分接口失败: %s", result.Msg)
|
|
}
|
|
return result.Data.Balance, nil
|
|
}
|
|
|
|
// GenerateCSRF 调用 generateCsrf，并从 Set-Cookie 中取 cvl_csrf_token。
|
|
func (c *DouyuClient) GenerateCSRF(cookie string) (string, error) {
|
|
req, err := http.NewRequest("POST", csrfURL, nil)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
c.setBrowserHeaders(req, cookie)
|
|
|
|
start := time.Now()
|
|
reqBody := traceRequestBody(c.trace, req)
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
c.trace.record("生成CSRF", req, 0, time.Since(start), reqBody, nil, err.Error(), 0, "")
|
|
logNetworkError("生成CSRF", req, time.Since(start), err)
|
|
return "", err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
c.trace.record("生成CSRF", req, resp.StatusCode, time.Since(start), reqBody, nil, err.Error(), 0, "")
|
|
logNetworkError("生成CSRF", req, time.Since(start), err)
|
|
return "", err
|
|
}
|
|
if resp.StatusCode != http.StatusOK {
|
|
c.trace.record("生成CSRF", req, resp.StatusCode, time.Since(start), reqBody, body, "", 0, "")
|
|
logNetworkHTTPError("生成CSRF", req, resp.StatusCode, time.Since(start), body)
|
|
return "", fmt.Errorf("CSRF HTTP %d: %s", resp.StatusCode, trimForLog(string(body), 120))
|
|
}
|
|
|
|
var api APIResponse
|
|
if err := json.Unmarshal(body, &api); err != nil {
|
|
c.trace.record("生成CSRF", req, resp.StatusCode, time.Since(start), reqBody, body, err.Error(), 0, "")
|
|
logNetworkParseError("生成CSRF", req, time.Since(start), body, err)
|
|
return "", fmt.Errorf("CSRF 响应解析失败: %w", err)
|
|
}
|
|
traceErr := ""
|
|
if api.Error != 0 {
|
|
traceErr = api.Msg
|
|
c.trace.record("生成CSRF", req, resp.StatusCode, time.Since(start), reqBody, body, traceErr, api.Error, api.Msg)
|
|
logNetworkAPIResult("生成CSRF", req, time.Since(start), api.Error, api.Msg)
|
|
return "", fmt.Errorf("CSRF 接口失败: %s", api.Msg)
|
|
}
|
|
for _, ck := range resp.Cookies() {
|
|
if ck.Name == "cvl_csrf_token" && ck.Value != "" {
|
|
c.trace.record("生成CSRF", req, resp.StatusCode, time.Since(start), reqBody, body, "", api.Error, api.Msg)
|
|
logNetworkSuccess("生成CSRF", req, time.Since(start), 0, "")
|
|
return ck.Value, nil
|
|
}
|
|
}
|
|
c.trace.record("生成CSRF", req, resp.StatusCode, time.Since(start), reqBody, body, "响应没有 cvl_csrf_token", api.Error, api.Msg)
|
|
logEvent("网络", "warn", "接口返回异常: 生成CSRF %s %s 耗时=%s msg=响应没有 cvl_csrf_token",
|
|
req.Method, requestPath(req), roundDuration(time.Since(start)))
|
|
return "", errors.New("CSRF 响应没有 cvl_csrf_token")
|
|
}
|
|
|
|
// BatchExchangeLimit 请求兑换限制接口，返回本次允许的批量上限。
|
|
func (c *DouyuClient) BatchExchangeLimit(cookie, commodityID, csrf string) (int, error) {
|
|
var result struct {
|
|
APIResponse
|
|
Data struct {
|
|
Limit string `json:"limit"`
|
|
} `json:"data"`
|
|
}
|
|
if err := c.postMultipart(batchLimitURL, cookie, csrf, "批量限制", map[string]string{
|
|
"manualID": manualID,
|
|
"commodityID": commodityID,
|
|
"rid": roomID,
|
|
"csrfToken": csrf,
|
|
}, &result); err != nil {
|
|
return 0, err
|
|
}
|
|
if result.Error != 0 {
|
|
return 0, fmt.Errorf("批量限制接口失败: %s", result.Msg)
|
|
}
|
|
limit, err := strconv.Atoi(result.Data.Limit)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("批量限制值无效: %q", result.Data.Limit)
|
|
}
|
|
return limit, nil
|
|
}
|
|
|
|
// PreExchange 按抓包流程执行预兑换检查。
|
|
func (c *DouyuClient) PreExchange(cookie, commodityID, csrf string) error {
|
|
var result APIResponse
|
|
if err := c.postMultipart(preExchangeURL, cookie, csrf, "预兑换", map[string]string{
|
|
"manualID": manualID,
|
|
"rid": roomID,
|
|
"commodityID": commodityID,
|
|
"num": "1",
|
|
"csrfToken": csrf,
|
|
}, &result); err != nil {
|
|
return err
|
|
}
|
|
if result.Error != 0 {
|
|
return fmt.Errorf("预兑换失败: %s", result.Msg)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Exchange 正式兑换一个商品，num 固定为 1，和浏览器抓包一致。
|
|
func (c *DouyuClient) Exchange(cookie, commodityID, csrf string) (string, error) {
|
|
var result struct {
|
|
APIResponse
|
|
Data struct {
|
|
ExchangeID int `json:"exchangeId"`
|
|
ExchangeNum string `json:"exchangeNum"`
|
|
CommodityTyp int `json:"commodityType"`
|
|
} `json:"data"`
|
|
}
|
|
if err := c.postMultipart(exchangeURL, cookie, csrf, "正式兑换", map[string]string{
|
|
"manualID": manualID,
|
|
"commodityID": commodityID,
|
|
"num": "1",
|
|
"rid": roomID,
|
|
"csrfToken": csrf,
|
|
}, &result); err != nil {
|
|
return "", err
|
|
}
|
|
if result.Error != 0 {
|
|
if strings.TrimSpace(result.Msg) == "" {
|
|
return "", errors.New("兑换失败，接口未返回原因")
|
|
}
|
|
return "", fmt.Errorf("兑换失败: %s", result.Msg)
|
|
}
|
|
return fmt.Sprintf("exchangeId=%d,num=%s", result.Data.ExchangeID, result.Data.ExchangeNum), nil
|
|
}
|
|
|
|
// RoleName 查询绑定角色名。
|
|
func (c *DouyuClient) RoleName(cookie string) (string, error) {
|
|
var result struct {
|
|
APIResponse
|
|
Data struct {
|
|
GameRole struct {
|
|
RoleName string `json:"roleName"`
|
|
} `json:"gameRole"`
|
|
} `json:"data"`
|
|
}
|
|
if err := c.getJSON(bindInfoURL, cookie, "角色绑定", &result); err != nil {
|
|
return "", err
|
|
}
|
|
if result.Error != 0 {
|
|
return "", fmt.Errorf("角色接口失败: %s", result.Msg)
|
|
}
|
|
return result.Data.GameRole.RoleName, nil
|
|
}
|
|
|
|
// getJSON 发送 GET 请求并解析 JSON。
|
|
func (c *DouyuClient) getJSON(url, cookie, label string, out any) error {
|
|
req, err := http.NewRequest("GET", url, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.setBrowserHeaders(req, cookie)
|
|
return c.doJSON(req, out, label)
|
|
}
|
|
|
|
// postMultipart 发送 multipart/form-data 请求并解析 JSON。
|
|
func (c *DouyuClient) postMultipart(url, cookie, csrf, label string, fields map[string]string, out any) error {
|
|
var body bytes.Buffer
|
|
writer := multipart.NewWriter(&body)
|
|
for key, value := range fields {
|
|
if err := writer.WriteField(key, value); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if err := writer.Close(); err != nil {
|
|
return err
|
|
}
|
|
|
|
req, err := http.NewRequest("POST", url, &body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.setBrowserHeaders(req, mergeCookie(cookie, "cvl_csrf_token", csrf))
|
|
req.Header.Set("Content-Type", writer.FormDataContentType())
|
|
return c.doJSON(req, out, label)
|
|
}
|
|
|
|
// doJSON 执行请求、检查 HTTP 状态码并解析 JSON。
|
|
func (c *DouyuClient) doJSON(req *http.Request, out any, label string) error {
|
|
start := time.Now()
|
|
reqBody := traceRequestBody(c.trace, req)
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
c.trace.record(label, req, 0, time.Since(start), reqBody, nil, err.Error(), 0, "")
|
|
logNetworkError(label, req, time.Since(start), err)
|
|
return err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
c.trace.record(label, req, resp.StatusCode, time.Since(start), reqBody, nil, err.Error(), 0, "")
|
|
logNetworkError(label, req, time.Since(start), err)
|
|
return err
|
|
}
|
|
if resp.StatusCode != http.StatusOK {
|
|
c.trace.record(label, req, resp.StatusCode, time.Since(start), reqBody, body, "", 0, "")
|
|
logNetworkHTTPError(label, req, resp.StatusCode, time.Since(start), body)
|
|
return fmt.Errorf("HTTP %d: %s", resp.StatusCode, trimForLog(string(body), 160))
|
|
}
|
|
if err := json.Unmarshal(body, out); err != nil {
|
|
c.trace.record(label, req, resp.StatusCode, time.Since(start), reqBody, body, err.Error(), 0, "")
|
|
logNetworkParseError(label, req, time.Since(start), body, err)
|
|
return fmt.Errorf("JSON 解析失败: %w, body=%s", err, trimForLog(string(body), 160))
|
|
}
|
|
if apiError, apiMsg, ok := extractAPIStatus(out); ok && apiError != 0 {
|
|
c.trace.record(label, req, resp.StatusCode, time.Since(start), reqBody, body, apiMsg, apiError, apiMsg)
|
|
logNetworkAPIResult(label, req, time.Since(start), apiError, apiMsg)
|
|
} else if shouldLogNetworkSuccess(label) {
|
|
c.trace.record(label, req, resp.StatusCode, time.Since(start), reqBody, body, "", 0, "")
|
|
logNetworkSuccess(label, req, time.Since(start), 0, "")
|
|
} else {
|
|
c.trace.record(label, req, resp.StatusCode, time.Since(start), reqBody, body, "", 0, "")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func shouldLogNetworkSuccess(label string) bool {
|
|
return label != "服务时间"
|
|
}
|
|
|
|
func logNetworkSuccess(label string, req *http.Request, cost time.Duration, apiError int, apiMsg string) {
|
|
if !shouldLogNetworkSuccess(label) {
|
|
return
|
|
}
|
|
extra := ""
|
|
if apiMsg != "" || apiError != 0 {
|
|
extra = fmt.Sprintf(" apiError=%d msg=%s", apiError, trimForLog(apiMsg, 80))
|
|
}
|
|
logEvent("网络", "info", "请求完成: %s %s %s 耗时=%s%s", label, req.Method, requestPath(req), roundDuration(cost), extra)
|
|
}
|
|
|
|
func logNetworkAPIResult(label string, req *http.Request, cost time.Duration, apiError int, apiMsg string) {
|
|
logEvent("网络", "warn", "接口返回异常: %s %s %s 耗时=%s apiError=%d msg=%s",
|
|
label, req.Method, requestPath(req), roundDuration(cost), apiError, trimForLog(apiMsg, 120))
|
|
}
|
|
|
|
func logNetworkHTTPError(label string, req *http.Request, status int, cost time.Duration, body []byte) {
|
|
logEvent("网络", "error", "HTTP异常: %s %s %s 状态=%d 耗时=%s 响应=%s",
|
|
label, req.Method, requestPath(req), status, roundDuration(cost), trimForLog(string(body), 160))
|
|
}
|
|
|
|
func logNetworkParseError(label string, req *http.Request, cost time.Duration, body []byte, err error) {
|
|
logEvent("网络", "error", "响应解析失败: %s %s %s 耗时=%s 错误=%v 响应=%s",
|
|
label, req.Method, requestPath(req), roundDuration(cost), err, trimForLog(string(body), 160))
|
|
}
|
|
|
|
func logNetworkError(label string, req *http.Request, cost time.Duration, err error) {
|
|
logEvent("网络", "error", "请求失败: %s %s %s 耗时=%s 错误=%v",
|
|
label, req.Method, requestPath(req), roundDuration(cost), err)
|
|
}
|
|
|
|
func requestPath(req *http.Request) string {
|
|
if req == nil || req.URL == nil {
|
|
return "-"
|
|
}
|
|
return req.URL.Path
|
|
}
|
|
|
|
func roundDuration(d time.Duration) time.Duration {
|
|
return d.Round(time.Millisecond)
|
|
}
|
|
|
|
func extractAPIStatus(out any) (int, string, bool) {
|
|
if out == nil {
|
|
return 0, "", false
|
|
}
|
|
v := reflect.ValueOf(out)
|
|
if v.Kind() == reflect.Pointer {
|
|
if v.IsNil() {
|
|
return 0, "", false
|
|
}
|
|
v = v.Elem()
|
|
}
|
|
if !v.IsValid() {
|
|
return 0, "", false
|
|
}
|
|
if v.Type() == reflect.TypeOf(APIResponse{}) {
|
|
api := v.Interface().(APIResponse)
|
|
return api.Error, api.Msg, true
|
|
}
|
|
if v.Kind() != reflect.Struct {
|
|
return 0, "", false
|
|
}
|
|
if field := v.FieldByName("APIResponse"); field.IsValid() && field.CanInterface() {
|
|
if api, ok := field.Interface().(APIResponse); ok {
|
|
return api.Error, api.Msg, true
|
|
}
|
|
}
|
|
errorField := v.FieldByName("Error")
|
|
msgField := v.FieldByName("Msg")
|
|
if errorField.IsValid() && msgField.IsValid() && errorField.CanInt() && msgField.Kind() == reflect.String {
|
|
return int(errorField.Int()), msgField.String(), true
|
|
}
|
|
return 0, "", false
|
|
}
|
|
|
|
// setBrowserHeaders 设置接近浏览器抓包的通用请求头。
|
|
func (c *DouyuClient) setBrowserHeaders(req *http.Request, cookie string) {
|
|
req.Header.Set("Accept", "application/json, text/plain, */*")
|
|
req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9,en-US;q=0.6,en;q=0.5")
|
|
req.Header.Set("User-Agent", userAgent)
|
|
req.Header.Set("Origin", baseURL)
|
|
req.Header.Set("Referer", shopReferer)
|
|
req.Header.Set("Sec-Fetch-Dest", "empty")
|
|
req.Header.Set("Sec-Fetch-Mode", "cors")
|
|
req.Header.Set("Sec-Fetch-Site", "same-origin")
|
|
if strings.TrimSpace(cookie) != "" {
|
|
req.Header.Set("Cookie", cookie)
|
|
}
|
|
}
|
|
|
|
// setJSONHeaders 设置 JSON POST 请求头。
|
|
func (c *DouyuClient) setJSONHeaders(req *http.Request, cookie string) {
|
|
c.setBrowserHeaders(req, cookie)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
}
|