64b264ee73
crawl_tasks 每品牌只有一行（uq_crawl_tasks_brand），入队/完成都是覆盖， 答不了「什么时候爬过、爬了几次、哪次没抓到」。故新增 append-only 历史表： - 在 Report 的同一事务里写一条：品牌 / 任务 / 状态 / 第几次尝试 / 场次上限 / 实际上报场次 / 错误 / 执行者 / 领取与回报时间 - 写入后只保留该品牌最近 30 条（CrawlLogKeepPerBrand）， 历史用于排障而非归档，避免无限增长 - 品牌详情页新增「抓取历史」区块（结果 / 明细 / 耗时 / 执行者）， 与「更新记录」上下相邻，构成「抓取一次 → 每场入库结果」的完整链路 量级：每品牌每次抓取 1 行、约 200B（含索引）；全站跑一遍 23237 行 ≈ 4.6MB。
385 lines
13 KiB
Go
385 lines
13 KiB
Go
package repository
|
||
|
||
import (
|
||
"context"
|
||
"strings"
|
||
"time"
|
||
|
||
"gorm.io/gorm"
|
||
|
||
"fashionapi/internal/model"
|
||
)
|
||
|
||
// CrawlRepository 品牌抓取任务（crawl_tasks）的数据访问。
|
||
//
|
||
// 任务表同时被两个方向使用：
|
||
// - 后台（cookie 会话）往里加任务 / 取消 / 重试；
|
||
// - spider 服务（HMAC 验签）来领取 / 回报结果。
|
||
//
|
||
// 领取用 `FOR UPDATE SKIP LOCKED`，多个 spider 实例并发领取不会抢到同一条。
|
||
type CrawlRepository interface {
|
||
// Enqueue 把单个品牌加入队列。
|
||
// 返回 true 表示新入队或把已完成/失败的任务重置为待领取；false 表示该品牌已在队列中/正在跑。
|
||
Enqueue(ctx context.Context, brandID uint32, maxShows int, priority int) (bool, error)
|
||
// EnqueueBulk 按「范围 + 前缀」批量入队，返回本次实际新入队（或重置）的数量。
|
||
EnqueueBulk(ctx context.Context, f BulkFilter) (int, error)
|
||
// Claim 领取一个待执行任务并置为 running；无任务时返回 nil, nil。
|
||
Claim(ctx context.Context, worker string) (*model.CrawlTaskRow, error)
|
||
// Report spider 回报结果。failed 且未达重试上限时自动回到 queued。
|
||
Report(ctx context.Context, id uint32, status string, shows int, errMsg string) error
|
||
// List 后台列表（按 running → queued → 其它 排序）。
|
||
List(ctx context.Context, offset, limit int) ([]model.CrawlTaskRow, int64, error)
|
||
// SetStatus 后台手动改状态（取消 / 重试）。
|
||
SetStatus(ctx context.Context, id uint32, status string) error
|
||
// Delete 删除任务记录（不影响已入库的数据）。
|
||
Delete(ctx context.Context, id uint32) error
|
||
// Counts 各状态任务数，供导航角标使用。
|
||
Counts(ctx context.Context) (map[string]int64, error)
|
||
// BrandCrawlStates 返回这些品牌在抓取队列里的「最近状态 + 最近时间」。
|
||
// 品牌列表用它展示「抓取状态 / 上次抓取」；没有任务记录的品牌不会出现在 map 里。
|
||
BrandCrawlStates(ctx context.Context, brandIDs []uint32) (map[uint32]BrandCrawlState, error)
|
||
// ListCrawlLogs 取某品牌最近的抓取历史（id 倒序），品牌详情页展示用。
|
||
//
|
||
// crawl_tasks 每品牌只有一行且会被覆盖，历史只存在 brand_crawl_logs 里。
|
||
ListCrawlLogs(ctx context.Context, brandID uint32, limit int) ([]model.CrawlLog, error)
|
||
}
|
||
|
||
// BrandCrawlState 品牌最近一次抓取任务的状态快照。
|
||
type BrandCrawlState struct {
|
||
Status string // queued / running / done / failed / canceled
|
||
UpdatedAt time.Time // 该任务最后一次更新时间
|
||
}
|
||
|
||
type crawlRepository struct {
|
||
db *gorm.DB
|
||
}
|
||
|
||
// NewCrawlRepository 创建爬取任务仓储。
|
||
func NewCrawlRepository(db *gorm.DB) CrawlRepository {
|
||
return &crawlRepository{db: db}
|
||
}
|
||
|
||
const crawlColumns = `t.id, t.brand_id, t.status, t.priority, t.max_shows, t.worker,
|
||
t.locked_at, t.attempts, t.shows_submitted, t.last_error, t.created_at, t.updated_at,
|
||
coalesce(b.name_en, '') AS brand_name`
|
||
|
||
func (r *crawlRepository) Enqueue(ctx context.Context, brandID uint32, maxShows int, priority int) (bool, error) {
|
||
now := uint32(time.Now().Unix())
|
||
// INSERT ... SELECT 保证品牌不存在（或已软删）时不会凭空建任务；
|
||
// ON CONFLICT 的 WHERE 让「已在排队/正在跑」的任务不被重置，避免打断正在执行的工作。
|
||
res := r.db.WithContext(ctx).Exec(`
|
||
INSERT INTO crawl_tasks (brand_id, status, priority, max_shows, created_at, updated_at)
|
||
SELECT b.id, ?, ?, ?, ?, ?
|
||
FROM brands b
|
||
WHERE b.id = ? AND b.is_deleted = 0
|
||
ON CONFLICT (brand_id) DO UPDATE
|
||
SET status = 'queued',
|
||
priority = EXCLUDED.priority,
|
||
max_shows = EXCLUDED.max_shows,
|
||
attempts = 0,
|
||
locked_at = 0,
|
||
worker = '',
|
||
shows_submitted = 0,
|
||
last_error = '',
|
||
updated_at = EXCLUDED.updated_at
|
||
WHERE crawl_tasks.status IN ('done', 'failed', 'canceled')`,
|
||
model.CrawlQueued, priority, maxShows, now, now, brandID)
|
||
if res.Error != nil {
|
||
return false, res.Error
|
||
}
|
||
return res.RowsAffected > 0, nil
|
||
}
|
||
|
||
// BulkScope 批量入队的品牌范围。
|
||
type BulkScope string
|
||
|
||
const (
|
||
// ScopeAll 所有品牌（首次全站导入用，量大）。
|
||
ScopeAll BulkScope = "all"
|
||
// ScopeWithData 只挑「已有图集」的品牌 —— 用于增量更新：只补最新场次。
|
||
ScopeWithData BulkScope = "with-data"
|
||
// ScopeWithoutData 只挑「还没有任何图集」的品牌 —— 用于首次补全。
|
||
ScopeWithoutData BulkScope = "without-data"
|
||
)
|
||
|
||
// BulkFilter 批量入队条件。
|
||
type BulkFilter struct {
|
||
Prefix string // 品牌英文名前缀，空 = 不限
|
||
Scope BulkScope // 范围（见上方常量）
|
||
MaxShows int // 0 = 不限场次（全量），>0 = 只抓最近 N 场
|
||
Limit int // 本次最多入队多少个品牌（防止一次灌爆）
|
||
Priority int16 // 越大越先被领取
|
||
}
|
||
|
||
func (r *crawlRepository) EnqueueBulk(ctx context.Context, f BulkFilter) (int, error) {
|
||
now := uint32(time.Now().Unix())
|
||
if f.Limit < 1 || f.Limit > 5000 {
|
||
f.Limit = 500
|
||
}
|
||
if f.Scope == "" {
|
||
f.Scope = ScopeAll
|
||
}
|
||
|
||
where := []string{"b.is_deleted = 0", "b.name_en <> ''"}
|
||
// 注意：参数顺序必须与 SQL 里 ? 出现的顺序严格一致（INSERT 的 4 个 + 每个 WHERE 条件 + LIMIT）。
|
||
args := []any{model.CrawlQueued, f.Priority, f.MaxShows, now, now}
|
||
|
||
if f.Prefix != "" {
|
||
where = append(where, `b.name_en ILIKE ? ESCAPE '\'`)
|
||
args = append(args, escapeLike(f.Prefix)+"%")
|
||
}
|
||
switch f.Scope {
|
||
case ScopeWithData:
|
||
where = append(where, "EXISTS (SELECT 1 FROM brand_runways r WHERE r.brand_id = b.id AND r.is_deleted = 0)")
|
||
case ScopeWithoutData:
|
||
where = append(where, "NOT EXISTS (SELECT 1 FROM brand_runways r WHERE r.brand_id = b.id AND r.is_deleted = 0)")
|
||
}
|
||
args = append(args, f.Limit)
|
||
|
||
sql := `
|
||
INSERT INTO crawl_tasks (brand_id, status, priority, max_shows, created_at, updated_at)
|
||
SELECT b.id, ?, ?, ?, ?, ?
|
||
FROM brands b
|
||
WHERE ` + strings.Join(where, " AND ") + `
|
||
ORDER BY EXISTS (SELECT 1 FROM crawl_tasks t WHERE t.brand_id = b.id) ASC, b.id ASC
|
||
LIMIT ?
|
||
ON CONFLICT (brand_id) DO UPDATE
|
||
SET status = 'queued',
|
||
priority = EXCLUDED.priority,
|
||
max_shows = EXCLUDED.max_shows,
|
||
attempts = 0,
|
||
locked_at = 0,
|
||
worker = '',
|
||
shows_submitted = 0,
|
||
last_error = '',
|
||
updated_at = EXCLUDED.updated_at
|
||
WHERE crawl_tasks.status IN ('done', 'failed', 'canceled')`
|
||
|
||
res := r.db.WithContext(ctx).Exec(sql, args...)
|
||
if res.Error != nil {
|
||
return 0, res.Error
|
||
}
|
||
return int(res.RowsAffected), nil
|
||
}
|
||
|
||
// escapeLike 转义 LIKE 的通配符，让用户输入按字面量匹配。
|
||
func escapeLike(s string) string {
|
||
out := make([]rune, 0, len(s))
|
||
for _, c := range s {
|
||
switch c {
|
||
case '%', '_', '\\':
|
||
out = append(out, '\\')
|
||
}
|
||
out = append(out, c)
|
||
}
|
||
return string(out)
|
||
}
|
||
|
||
func (r *crawlRepository) Claim(ctx context.Context, worker string) (*model.CrawlTaskRow, error) {
|
||
now := uint32(time.Now().Unix())
|
||
|
||
tx := r.db.WithContext(ctx).Begin()
|
||
if tx.Error != nil {
|
||
return nil, tx.Error
|
||
}
|
||
defer func() {
|
||
if tx.Error != nil {
|
||
tx.Rollback()
|
||
}
|
||
}()
|
||
|
||
// 回收租约过期的 running（worker 崩溃 / 断电），否则任务永远卡着。
|
||
if now > model.CrawlStuckTimeoutSec {
|
||
if err := tx.Exec(`
|
||
UPDATE crawl_tasks
|
||
SET status = 'queued', locked_at = 0, worker = '', updated_at = ?
|
||
WHERE status = 'running' AND locked_at > 0 AND locked_at < ?`,
|
||
now, now-model.CrawlStuckTimeoutSec).Error; err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
|
||
var id uint32
|
||
if err := tx.Raw(`
|
||
SELECT id FROM crawl_tasks
|
||
WHERE status = 'queued'
|
||
ORDER BY priority DESC, id ASC
|
||
LIMIT 1
|
||
FOR UPDATE SKIP LOCKED`).Scan(&id).Error; err != nil {
|
||
return nil, err
|
||
}
|
||
if id == 0 {
|
||
if err := tx.Commit().Error; err != nil {
|
||
return nil, err
|
||
}
|
||
return nil, nil
|
||
}
|
||
|
||
if err := tx.Exec(`
|
||
UPDATE crawl_tasks
|
||
SET status = 'running', worker = ?, locked_at = ?, attempts = attempts + 1, updated_at = ?
|
||
WHERE id = ?`, worker, now, now, id).Error; err != nil {
|
||
return nil, err
|
||
}
|
||
if err := tx.Commit().Error; err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
var row model.CrawlTaskRow
|
||
if err := r.db.WithContext(ctx).Raw(`
|
||
SELECT `+crawlColumns+`
|
||
FROM crawl_tasks t LEFT JOIN brands b ON b.id = t.brand_id
|
||
WHERE t.id = ?`, id).Scan(&row).Error; err != nil {
|
||
return nil, err
|
||
}
|
||
return &row, nil
|
||
}
|
||
|
||
func (r *crawlRepository) Report(ctx context.Context, id uint32, status string, shows int, errMsg string) error {
|
||
now := uint32(time.Now().Unix())
|
||
return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||
var cur model.CrawlTask
|
||
if err := tx.Where("id = ?", id).First(&cur).Error; err != nil {
|
||
return err
|
||
}
|
||
|
||
next := status
|
||
// 失败但还有重试额度 → 回到队列，由任意 worker 重试（网络抖动不必人工介入）。
|
||
if status == model.CrawlFailed && cur.Attempts < model.CrawlMaxAttempts {
|
||
next = model.CrawlQueued
|
||
}
|
||
if err := tx.Model(&model.CrawlTask{}).Where("id = ?", id).
|
||
Updates(map[string]any{
|
||
"status": next,
|
||
"shows_submitted": shows,
|
||
"last_error": errMsg,
|
||
"locked_at": 0,
|
||
"worker": "",
|
||
"updated_at": now,
|
||
}).Error; err != nil {
|
||
return err
|
||
}
|
||
|
||
// 同事务写一条抓取历史：crawl_tasks 每品牌只有一行会被覆盖，
|
||
// 不在这里留痕就永远查不到「上次爬是什么时候、抓到几场」。
|
||
log := model.CrawlLog{
|
||
BrandID: cur.BrandID,
|
||
TaskID: cur.ID,
|
||
Status: status,
|
||
Attempt: cur.Attempts + 1,
|
||
ShowsRequested: cur.MaxShows,
|
||
ShowsSubmitted: int32(shows),
|
||
Message: errMsg,
|
||
Worker: cur.Worker,
|
||
StartedAt: cur.LockedAt,
|
||
FinishedAt: now,
|
||
}
|
||
if err := tx.Create(&log).Error; err != nil {
|
||
return err
|
||
}
|
||
|
||
// 只保留该品牌最近 N 条：历史用于排障，不是归档，避免无限增长。
|
||
return tx.Exec(
|
||
"DELETE FROM brand_crawl_logs WHERE brand_id = ? AND id < "+
|
||
"(SELECT id FROM brand_crawl_logs WHERE brand_id = ? ORDER BY id DESC OFFSET ? LIMIT 1)",
|
||
cur.BrandID, cur.BrandID, model.CrawlLogKeepPerBrand).Error
|
||
})
|
||
}
|
||
|
||
func (r *crawlRepository) List(ctx context.Context, offset, limit int) ([]model.CrawlTaskRow, int64, error) {
|
||
if limit < 1 {
|
||
limit = 30
|
||
}
|
||
var total int64
|
||
if err := r.db.WithContext(ctx).Table("crawl_tasks").Count(&total).Error; err != nil {
|
||
return nil, 0, err
|
||
}
|
||
var rows []model.CrawlTaskRow
|
||
err := r.db.WithContext(ctx).Raw(`
|
||
SELECT `+crawlColumns+`
|
||
FROM crawl_tasks t LEFT JOIN brands b ON b.id = t.brand_id
|
||
ORDER BY CASE t.status WHEN 'running' THEN 0 WHEN 'queued' THEN 1 ELSE 2 END,
|
||
t.priority DESC, t.id DESC
|
||
LIMIT ? OFFSET ?`, limit, offset).Scan(&rows).Error
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
return rows, total, nil
|
||
}
|
||
|
||
func (r *crawlRepository) SetStatus(ctx context.Context, id uint32, status string) error {
|
||
return r.db.WithContext(ctx).Model(&model.CrawlTask{}).Where("id = ?", id).
|
||
Updates(map[string]any{
|
||
"status": status,
|
||
"locked_at": 0,
|
||
"worker": "",
|
||
"attempts": 0,
|
||
"last_error": "",
|
||
"updated_at": uint32(time.Now().Unix()),
|
||
}).Error
|
||
}
|
||
|
||
func (r *crawlRepository) Delete(ctx context.Context, id uint32) error {
|
||
return r.db.WithContext(ctx).Exec(`DELETE FROM crawl_tasks WHERE id = ?`, id).Error
|
||
}
|
||
|
||
// ListCrawlLogs 取某品牌最近的抓取历史。
|
||
func (r *crawlRepository) ListCrawlLogs(ctx context.Context, brandID uint32, limit int) ([]model.CrawlLog, error) {
|
||
if brandID == 0 || limit <= 0 {
|
||
return nil, nil
|
||
}
|
||
var rows []model.CrawlLog
|
||
if err := r.db.WithContext(ctx).
|
||
Where("brand_id = ?", brandID).
|
||
Order("id DESC").
|
||
Limit(limit).
|
||
Find(&rows).Error; err != nil {
|
||
return nil, err
|
||
}
|
||
return rows, nil
|
||
}
|
||
|
||
func (r *crawlRepository) BrandCrawlStates(ctx context.Context, brandIDs []uint32) (map[uint32]BrandCrawlState, error) {
|
||
out := make(map[uint32]BrandCrawlState, len(brandIDs))
|
||
if len(brandIDs) == 0 {
|
||
return out, nil
|
||
}
|
||
var rows []struct {
|
||
BrandID uint32
|
||
Status string
|
||
UpdatedAt int64
|
||
}
|
||
// DISTINCT ON 取每个品牌最近一条任务（按 updated_at 倒序），一次查询拿全状态与时间。
|
||
if err := r.db.WithContext(ctx).Raw(`
|
||
SELECT DISTINCT ON (brand_id) brand_id, status, updated_at
|
||
FROM crawl_tasks
|
||
WHERE brand_id IN ?
|
||
ORDER BY brand_id, updated_at DESC`, brandIDs).Scan(&rows).Error; err != nil {
|
||
return out, err
|
||
}
|
||
for _, row := range rows {
|
||
st := BrandCrawlState{Status: row.Status}
|
||
if row.UpdatedAt > 0 {
|
||
st.UpdatedAt = time.Unix(row.UpdatedAt, 0)
|
||
}
|
||
out[row.BrandID] = st
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (r *crawlRepository) Counts(ctx context.Context) (map[string]int64, error) {
|
||
var rows []struct {
|
||
Status string
|
||
N int64
|
||
}
|
||
if err := r.db.WithContext(ctx).Raw(
|
||
`SELECT status, count(*) AS n FROM crawl_tasks GROUP BY status`).Scan(&rows).Error; err != nil {
|
||
return nil, err
|
||
}
|
||
out := make(map[string]int64, len(rows))
|
||
for _, r := range rows {
|
||
out[r.Status] = r.N
|
||
}
|
||
return out, nil
|
||
}
|