forked from longtao.wu/droboticflow
142 lines
6.4 KiB
Go
142 lines
6.4 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"droboticflow/internal/config"
|
|
"droboticflow/internal/domain"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func annotationProcessorFixture(t *testing.T) (combinedDraftFixture, string) {
|
|
t.Helper()
|
|
if _, e := exec.LookPath("ffmpeg"); e != nil {
|
|
t.Skip("ffmpeg required")
|
|
}
|
|
f := newCombinedDraftFixture(t)
|
|
if e := f.store.UpsertOrganization(f.ctx, domain.OrganizationRecord{ID: domain.DefaultOrganizationID, Name: "Processor test", Status: domain.OrganizationStatusActive}); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
root := t.TempDir()
|
|
seedSliceDictionary(t, f, "测试切片")
|
|
task := f.task
|
|
task.NodeID = "human"
|
|
task.ArtifactID = "left-video"
|
|
task.RightArtifactID = "right-video"
|
|
task.ClipEnd = 4
|
|
task.SourceIsFullVideo = true
|
|
task.SourceDurationSeconds = 4
|
|
task.CoverageStartSecond = 0
|
|
task.CoverageEndSecond = 4
|
|
task.CoverageMode = "full_common_range"
|
|
pts, imu := "timestamp_us\n", "timestamp_us,x,y,z,type\n"
|
|
for i := 0; i < 32; i++ {
|
|
stamp := 1000000 + i*125000
|
|
pts += fmt.Sprintf("%d\n", stamp)
|
|
imu += fmt.Sprintf("%d,1,2,3,accel\n%d,4,5,6,gyro\n", stamp, stamp)
|
|
}
|
|
bindings := []domain.NodeInputBinding{}
|
|
for _, side := range []string{"left", "right"} {
|
|
video := filepath.Join(root, side+".mp4")
|
|
if out, e := exec.Command("ffmpeg", "-v", "error", "-y", "-f", "lavfi", "-i", "testsrc2=s=64x48:r=8:d=4", "-c:v", "libx264", "-pix_fmt", "yuv420p", video).CombinedOutput(); e != nil {
|
|
t.Fatalf("%v: %s", e, out)
|
|
}
|
|
p := filepath.Join(root, side+"_pts.csv")
|
|
os.WriteFile(p, []byte(pts), 0600)
|
|
videoPort := "fullLeftVideos"
|
|
if side == "right" {
|
|
videoPort = "fullRightVideos"
|
|
}
|
|
bindings = append(bindings, domain.NodeInputBinding{TargetPortID: videoPort, Artifacts: []domain.ExecutionArtifact{{ID: side + "-video", Name: side + ".mp4", Path: video, Data: map[string]any{"collectionId": "capture"}}}}, domain.NodeInputBinding{TargetPortID: side + "Timestamps", Artifacts: []domain.ExecutionArtifact{{ID: side + "-pts", Name: side + "_pts.csv", Path: p, Data: map[string]any{"collectionId": "capture"}}}})
|
|
}
|
|
p := filepath.Join(root, "imu.csv")
|
|
os.WriteFile(p, []byte(imu), 0600)
|
|
bindings = append(bindings, domain.NodeInputBinding{TargetPortID: "imu", Artifacts: []domain.ExecutionArtifact{{ID: "imu", Name: "imu.csv", Path: p, Data: map[string]any{"collectionId": "capture"}}}})
|
|
f.store.UpsertRun(f.ctx, domain.RunRecord{ID: task.RunID, OrganizationID: task.OrganizationID, ProjectID: task.ProjectID, WorkflowID: task.WorkflowID, NodeExecutions: []domain.NodeExecutionRecord{{NodeID: task.NodeID, InputBindings: bindings}}})
|
|
f.store.UpsertAnnotationTask(f.ctx, task)
|
|
f.task = task
|
|
f.handler = NewHandlerWithConfig(f.store, nil, config.AppConfig{WorkspaceMountPath: root})
|
|
return f, root
|
|
}
|
|
|
|
func TestDurableAnnotationOutboxSurvivesRestartAndFencesOldWorker(t *testing.T) {
|
|
t.Setenv("ANNOTATION_PROCESSOR_MODE", "external")
|
|
f, root := annotationProcessorFixture(t)
|
|
slices := []domain.SliceSegment{{ID: "a", Name: "测试切片", Start: 0, End: 2}, {ID: "b", Name: "测试切片", Start: 2, End: 4}}
|
|
r := f.request(http.MethodPost, "/api/plugins/annotation-qa/tasks/"+f.task.ID+"/slice-confirmations", f.annotator, map[string]any{"version": f.item.Version, "sliceSegments": slices})
|
|
if r.Code != 202 {
|
|
t.Fatal(r.Code, r.Body.String())
|
|
}
|
|
h, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
|
|
if h.ProcessingJob == nil || h.ProcessingJob.Status != "queued" || len(h.ProcessingJob.Input) == 0 {
|
|
t.Fatal("missing atomic outbox")
|
|
}
|
|
if b, _ := json.Marshal(h); stringContains(string(b), "processingJob") || stringContains(string(b), "sourceFingerprint") {
|
|
t.Fatal("private outbox leaked")
|
|
}
|
|
// A new API instance must not clear a durable job when it has no local map.
|
|
f.handler = NewHandlerWithConfig(f.store, nil, config.AppConfig{WorkspaceMountPath: root})
|
|
r = f.request(http.MethodGet, "/api/plugins/annotation-qa/tasks/"+f.task.ID+"?view=status", f.annotator, nil)
|
|
if r.Code != 200 {
|
|
t.Fatal(r.Code, r.Body.String())
|
|
}
|
|
now := time.Now().UTC()
|
|
old, _ := f.store.ClaimAnnotationProcessing(f.ctx, "dead-worker", now.Format(time.RFC3339Nano), now.Add(-time.Second).Format(time.RFC3339Nano))
|
|
claimed, _ := f.store.ClaimAnnotationProcessing(f.ctx, "replacement-worker", now.Format(time.RFC3339Nano), now.Add(time.Minute).Format(time.RFC3339Nano))
|
|
if old == nil || claimed == nil || claimed.ProcessingJob.Attempt != 2 {
|
|
t.Fatal("lease not recovered")
|
|
}
|
|
if ok, _ := f.store.UpdateHumanItemVersioned(f.ctx, *old, old.Version); ok {
|
|
t.Fatal("expired worker can publish")
|
|
}
|
|
p := &server{store: f.store, workspaceMountPath: root, externalAnnotationProcessor: true}
|
|
p.executeAnnotationJob(context.Background(), *claimed)
|
|
h, _ = f.store.GetHumanItem(f.ctx, f.item.ID)
|
|
if h.ProcessingJob.Status != "completed" || len(h.ProcessingJob.Input) != 0 || stringValue(mapValue(h.Subject.Payload["sliceWorkflow"])["status"]) != "completed" {
|
|
t.Fatalf("slice job failed: %+v", h.ProcessingJob)
|
|
}
|
|
baseHandler := f.handler
|
|
f.handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
r.Header.Set("Prefer", "respond-async")
|
|
baseHandler.ServeHTTP(w, r)
|
|
})
|
|
r = f.request(http.MethodPost, "/api/plugins/annotation-qa/tasks/"+f.task.ID+"/combined-submissions", f.annotator, map[string]any{"version": h.Version, "sliceSegments": slices, "segments": []any{}, "requireSliceCompletion": true})
|
|
if r.Code != 202 {
|
|
t.Fatal(r.Code, r.Body.String())
|
|
}
|
|
before, _ := f.store.GetHumanItem(f.ctx, h.ID)
|
|
if before.PendingCombinedSubmissionID == "" || before.ProcessingJob.Kind != "submit" {
|
|
t.Fatal("submission not atomically queued")
|
|
}
|
|
job, _ := f.store.ClaimAnnotationProcessing(f.ctx, "submit-worker", now.Format(time.RFC3339Nano), now.Add(time.Minute).Format(time.RFC3339Nano))
|
|
if job == nil {
|
|
t.Fatal("submission not claimable")
|
|
}
|
|
p.executeAnnotationJob(context.Background(), *job)
|
|
after, _ := f.store.GetHumanItem(f.ctx, h.ID)
|
|
if after.CurrentStageID != "quality_review" || after.ProcessingJob.Status != "completed" || after.PendingCombinedSubmissionID != "" {
|
|
t.Fatalf("submission failed %+v", after.ProcessingJob)
|
|
}
|
|
run, _ := f.store.GetRun(f.ctx, f.task.RunID)
|
|
found := false
|
|
for _, a := range run.Artifacts {
|
|
if boolValue(a.Data["metadataOnly"]) {
|
|
found = true
|
|
}
|
|
}
|
|
if !found {
|
|
t.Fatal("unchanged media was rebuilt")
|
|
}
|
|
}
|
|
|
|
func stringContains(s, part string) bool {
|
|
return len(part) > 0 && len(s) >= len(part) && strings.Contains(s, part)
|
|
}
|