Files
knowledge-governance/internal/workflows/testweknora/poll.go
T
dev 8e6094e9e5
build / build (push) Successful in 2m6s
feat(settings): worker 能力心跳读取 + 封存源对照 + 知识库映射合并
F01:新增 /api/v1/system/worker-capabilities,按 job_types 判定 test.upload 执行器是否注册,
服务卡片分「地址可达 / 凭据与库读取 / 执行器能力」三行。
F04:routing-bindings 返回 LIBRARY_SOURCE_KB_* 与一致性,设置页同屏显示入库目标与封存源。
结构:测试绑定与生产目标合并为「知识库映射」。
2026-11-17 16:04:00 +08:00

153 lines
5.2 KiB
Go

package testweknora
import (
"context"
"errors"
"time"
"knowledge-governance/internal/governance"
"knowledge-governance/internal/jobs"
postgresstore "knowledge-governance/internal/platform/postgres"
"knowledge-governance/internal/platform/weknora"
)
var (
ErrInvalidPollJobPayload = errors.New("test_poll_invalid_payload")
ErrPollRemoteFailed = errors.New("test_poll_remote_failed")
ErrPollRemoteIdentity = errors.New("test_poll_remote_identity_invalid")
ErrPollStateConflict = errors.New("test_poll_state_conflict")
)
type PollStore interface {
LoadPublicationForPoll(context.Context, string) (postgresstore.PublicationForPoll, error)
RecordRemoteStatusAndScheduleNextPoll(context.Context, string, int, governance.ProcessingState, *time.Time, time.Time, time.Time) (int, error)
RecordCompletedAndScheduleValidation(context.Context, string, int, *time.Time, time.Time) error
RecordProcessingFailure(context.Context, string, int, string, time.Time) error
MarkStalled(context.Context, string, int, time.Time, time.Time) error
}
type PollClient interface {
GetKnowledge(context.Context, string) (weknora.Knowledge, error)
}
type PollHandlerConfig struct {
Store PollStore
Client PollClient
PollDelay time.Duration
StallAfter time.Duration
// StallAfterSource 可选:返回当前生效的停滞阈值(来自活动 UI 配置)。
StallAfterSource func() time.Duration
Now func() time.Time
}
type PollHandler struct {
store PollStore
client PollClient
pollDelay time.Duration
stallAfter time.Duration
// stallAfterSource 存在时优先于 stallAfter:页面保存的“解析停滞阈值”
// 必须真的决定判定,而不是只写进数据库。
stallAfterSource func() time.Duration
now func() time.Time
}
type pollPayload struct {
PublicationID string `json:"publication_id"`
Sequence int `json:"sequence"`
}
func NewPollHandler(config PollHandlerConfig) (*PollHandler, error) {
if config.Store == nil || config.Client == nil || config.PollDelay <= 0 || config.StallAfter <= 0 {
return nil, errors.New("invalid test poll handler configuration")
}
if config.Now == nil {
config.Now = time.Now
}
return &PollHandler{
store: config.Store, client: config.Client, pollDelay: config.PollDelay,
stallAfter: config.StallAfter, stallAfterSource: config.StallAfterSource, now: config.Now,
}, nil
}
func (handler *PollHandler) Handle(ctx context.Context, job jobs.Job) error {
var payload pollPayload
if err := decodeStrictJSON(job.Payload, &payload); err != nil || payload.PublicationID == "" || payload.Sequence < 1 {
return jobs.Permanent(jobs.ErrCodeHandlerFallback, ErrInvalidPollJobPayload)
}
publication, err := handler.store.LoadPublicationForPoll(ctx, payload.PublicationID)
if err != nil {
return ErrPollStateConflict
}
if publication.KnowledgeID == "" || publication.PollSequence != payload.Sequence {
return ErrPollStateConflict
}
now := handler.now()
knowledge, err := handler.client.GetKnowledge(ctx, publication.KnowledgeID)
if err != nil {
return ErrPollRemoteFailed
}
if knowledge.ID != publication.KnowledgeID || knowledge.KnowledgeBaseID != publication.TestKBID {
return ErrPollRemoteIdentity
}
state := mapParseStatus(knowledge.ParseStatus)
if state == governance.ProcessingCompleted {
if err := handler.store.RecordCompletedAndScheduleValidation(ctx, publication.ID, publication.PollSequence, &knowledge.UpdatedAt, now); err != nil {
return ErrPollStateConflict
}
return nil
}
if state == governance.ProcessingFailed {
if err := handler.store.RecordProcessingFailure(ctx, publication.ID, publication.PollSequence, "remote_parse_failed", now); err != nil {
return ErrPollStateConflict
}
return nil
}
if !state.Valid() {
if err := handler.store.RecordProcessingFailure(ctx, publication.ID, publication.PollSequence, "remote_unknown_status", now); err != nil {
return ErrPollStateConflict
}
return nil
}
stall := handler.stallAfter
if handler.stallAfterSource != nil {
if fromSettings := handler.stallAfterSource(); fromSettings > 0 {
stall = fromSettings
}
}
cutoff := now.Add(-stall)
lastProgress := publication.LastProgressAt
if lastProgress == nil {
lastProgress = publication.ProcessingStartedAt
}
if lastProgress == nil {
lastProgress = publication.LastObservedAt
}
if lastProgress != nil && !lastProgress.After(cutoff) {
if err := handler.store.MarkStalled(ctx, publication.ID, publication.PollSequence, cutoff, now); err != nil {
return ErrPollStateConflict
}
return nil
}
if _, err := handler.store.RecordRemoteStatusAndScheduleNextPoll(ctx, publication.ID, publication.PollSequence, state, &knowledge.UpdatedAt, now, now.Add(handler.pollDelay)); err != nil {
return ErrPollStateConflict
}
return nil
}
func mapParseStatus(status string) governance.ProcessingState {
switch status {
case "pending":
return governance.ProcessingPending
case "processing":
return governance.ProcessingProcessing
case "finalizing":
return governance.ProcessingFinalizing
case "completed":
return governance.ProcessingCompleted
case "failed":
return governance.ProcessingFailed
default:
return governance.ProcessingState(status)
}
}