Files
knowledge-governance/internal/platform/postgres/store.go
T
姚章浩 5bf4aae30e
build / build (push) Successful in 1m42s
fix(ui): 接通取件后自动解析与一次性定位
F17:MarkArtifactFetched 与已验证内容复用都在同一事务内经过策略、来源启用、
过滤、superseded 和当前绑定的复核后,自动把 planned 转 pending 并入队唯一
test.upload;确认与作业幂等,失败整笔回滚。356 已卡记录可对同一文件再次保存
当前策略,经同一路径恢复,不做全库补扫或手工补队列。来源页提示改为自动接续。

F14:来源→监控定位清空未结束/动作/阶段/时间筛选;来源目录定位改为一次性请求
并由父消费,revision/sources 重载不再重放旧请求,手工换目录保持。

F13:抽出 readiness.Resolver 作为端点/绑定/凭据唯一来源;worker 上传/轮询/
校验/移除改用动态客户端,每次调用重读有效配置,不再固化启动 env 客户端。

验证:隔离 PG 的 F17 正负例与恢复用例、前端挂载定位回归、全量 Go/前端测试
及 make verify 17 项通过。未部署、未做 8088 UI 验收。
2026-11-05 11:46:42 +08:00

232 lines
6.7 KiB
Go

package postgres
import (
"context"
"errors"
"fmt"
"strings"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"knowledge-governance/internal/jobs"
)
var ErrLeaseLost = errors.New("job lease lost")
type database interface {
QueryRow(ctx context.Context, sql string, args ...any) pgx.Row
Exec(ctx context.Context, sql string, args ...any) (pgconn.CommandTag, error)
Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error)
Begin(ctx context.Context) (pgx.Tx, error)
}
type Store struct {
db database
libraryTargetID string
defaultInternalKBID string
defaultExternalKBID string
// restoreDispatchEvidenceRoot 是激活门唯一允许读取维护 journal 的根目录。
// 空值表示没有配置受信证据源:激活必须失败关闭,而不是退回"只看字符串"。
restoreDispatchEvidenceRoot string
}
// WithLibraryTarget isolates release facts without mutating a shared Store.
// The empty namespace retains legacy evidence; live API/workers bind a nonempty
// identity before exposing library operations. Source seals remain independent.
func (s *Store) WithLibraryTarget(id string) *Store {
copy := *s
copy.libraryTargetID = id
return &copy
}
func NewStore(db database) *Store {
return &Store{db: db}
}
// WithRoutingDefaults supplies the deployment's bootstrap bindings. The UI
// binding row still wins; defaults are only the unbound fallback, exactly like
// the route/readiness resolvers. Auto-continuation uses them only to prove the
// publication still targets the CURRENT effective knowledge base.
func (s *Store) WithRoutingDefaults(internal, external string) *Store {
copy := *s
copy.defaultInternalKBID = strings.TrimSpace(internal)
copy.defaultExternalKBID = strings.TrimSpace(external)
return &copy
}
// WithRestoreDispatchEvidence 绑定维护 journal 的受信根目录(部署配置
// LIBRARY_TARGET_JOURNAL_ROOT)。没有它时激活门一律失败关闭。
func (s *Store) WithRestoreDispatchEvidence(root string) *Store {
copy := *s
copy.restoreDispatchEvidenceRoot = root
return &copy
}
func (s *Store) Enqueue(ctx context.Context, request jobs.EnqueueRequest, now time.Time) (*jobs.Job, error) {
job, err := scanJob(s.db.QueryRow(
ctx,
enqueueJobSQL,
request.ID,
request.Type,
request.Payload,
request.Priority,
request.AvailableAt,
request.MaxAttempts,
request.IdempotencyKey,
now,
))
if err != nil {
return nil, fmt.Errorf("enqueue job: %w", err)
}
return job, nil
}
func (s *Store) Claim(ctx context.Context, workerID string, allowedTypes []string, now time.Time, leaseDuration time.Duration) (*jobs.Job, error) {
// Liveness heartbeat: refresh even on an empty claim so a healthy idle
// worker still looks alive to /readyz and the monitor matrix.
if _, err := s.db.Exec(ctx, workerHeartbeatSQL, workerID, strings.Join(allowedTypes, ","), now); err != nil {
return nil, fmt.Errorf("record worker heartbeat: %w", err)
}
job, err := scanJob(s.db.QueryRow(ctx, claimJobSQL, workerID, now, now.Add(leaseDuration), allowedTypes))
if errors.Is(err, pgx.ErrNoRows) {
return nil, nil
}
if err != nil {
return nil, fmt.Errorf("claim job: %w", err)
}
return job, nil
}
// ListByType lists only the requested job type, so a busy queue cannot hide the
// caller's own recent jobs behind unrelated traffic.
func (s *Store) ListByType(ctx context.Context, jobType string, limit int) ([]jobs.Job, error) {
if strings.TrimSpace(jobType) == "" || limit < 1 || limit > 200 {
return nil, errors.New("list jobs by type requires a type and a bounded limit")
}
rows, err := s.db.Query(ctx, listJobsByTypeSQL, jobType, limit)
if err != nil {
return nil, fmt.Errorf("list jobs by type: %w", err)
}
defer rows.Close()
result := make([]jobs.Job, 0, limit)
for rows.Next() {
job, err := scanJob(rows)
if err != nil {
return nil, fmt.Errorf("scan listed job: %w", err)
}
result = append(result, *job)
}
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("iterate jobs: %w", err)
}
return result, nil
}
func (s *Store) List(ctx context.Context, limit int) ([]jobs.Job, error) {
rows, err := s.db.Query(ctx, listJobsSQL, limit)
if err != nil {
return nil, fmt.Errorf("list jobs: %w", err)
}
defer rows.Close()
result := make([]jobs.Job, 0)
for rows.Next() {
job, err := scanJob(rows)
if err != nil {
return nil, fmt.Errorf("scan listed job: %w", err)
}
result = append(result, *job)
}
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("iterate jobs: %w", err)
}
return result, nil
}
func (s *Store) Complete(ctx context.Context, id, owner string, now time.Time) error {
// completeJobSQL is one statement: mark the job completed AND retire any
// open dead-letter rows for it. The EXISTS projection is the lease check.
var completed bool
if err := s.db.QueryRow(ctx, completeJobSQL, id, owner, now).Scan(&completed); err != nil {
return fmt.Errorf("complete job: %w", err)
}
if !completed {
return ErrLeaseLost
}
return nil
}
func (s *Store) Heartbeat(ctx context.Context, id, owner string, now time.Time, leaseDuration time.Duration) error {
tag, err := s.db.Exec(ctx, heartbeatJobSQL, id, owner, now, now.Add(leaseDuration))
if err != nil {
return fmt.Errorf("heartbeat job: %w", err)
}
if tag.RowsAffected() != 1 {
return ErrLeaseLost
}
return nil
}
func (s *Store) Fail(ctx context.Context, id, owner, message, code string, now, retryAt time.Time) error {
tag, err := s.db.Exec(ctx, failJobSQL, id, owner, message, now, code, retryAt)
if err != nil {
return fmt.Errorf("fail job: %w", err)
}
if tag.RowsAffected() != 1 {
return ErrLeaseLost
}
return nil
}
// FailTerminal implements jobs.TerminalFailer (P6): park the job in 'failed'
// immediately with a stable error code and project the dead-letter row.
func (s *Store) FailTerminal(ctx context.Context, id, owner, message, code string, now time.Time) error {
tag, err := s.db.Exec(ctx, failTerminalJobSQL, id, owner, message, code, now)
if err != nil {
return fmt.Errorf("fail terminal job: %w", err)
}
if tag.RowsAffected() != 1 {
return ErrLeaseLost
}
return nil
}
type rowScanner interface {
Scan(dest ...any) error
}
func scanJob(row rowScanner) (*jobs.Job, error) {
job := &jobs.Job{}
var state string
var leaseOwner *string
var lastError *string
if err := row.Scan(
&job.ID,
&job.Type,
&job.Payload,
&state,
&job.Priority,
&job.AvailableAt,
&leaseOwner,
&job.LeaseUntil,
&job.Attempt,
&job.MaxAttempts,
&lastError,
&job.IdempotencyKey,
&job.CreatedAt,
&job.UpdatedAt,
); err != nil {
return nil, err
}
job.State = jobs.State(state)
if leaseOwner != nil {
job.LeaseOwner = *leaseOwner
}
if lastError != nil {
job.LastError = *lastError
}
return job, nil
}