154 lines
5.6 KiB
Go
154 lines
5.6 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/pipeline"
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
"git.a-wan.net/alan/pipelines/internal/stage"
|
|
)
|
|
|
|
func TestCancelWaitsForContextIgnoringExecutor(t *testing.T) {
|
|
ctx, r, pipelineID := concurrentStore(t)
|
|
entered, release := make(chan struct{}, 1), make(chan struct{})
|
|
var releaseOnce sync.Once
|
|
stopExecutor := func() { releaseOnce.Do(func() { close(release) }) }
|
|
r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) {
|
|
entered <- struct{}{}
|
|
<-release // Deliberately ignore the canceled context.
|
|
return stage.Result{Outcome: "success", Output: stage.Values{}}, nil
|
|
}
|
|
defer func() { stopExecutor(); r.wg.Wait() }()
|
|
workspace := t.TempDir()
|
|
request := protocol.Message{PipelineID: pipelineID, Version: 1, RequestKey: "blocking", Workspace: workspace, Input: map[string]any{"prompt": "task"}}
|
|
run, err := r.start(request)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
waitEntered(t, entered)
|
|
if err := r.cancel(run.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := r.cancel(run.ID); err != nil {
|
|
t.Fatal("repeated stop must be idempotent", err)
|
|
}
|
|
detail, err := r.getRun(run.ID)
|
|
if err != nil || detail.Status != "running" || !detail.Executing || !detail.CancelRequested || detail.FinishedAt != "" || detail.Steps[0].Status != "running" || detail.Steps[0].FinishedAt != "" {
|
|
t.Fatalf("stop request falsely settled execution: %+v %v", detail, err)
|
|
}
|
|
request.RequestKey = "conflict"
|
|
if _, err := r.start(request); err == nil {
|
|
t.Fatal("stopping workspace was released")
|
|
}
|
|
// An actual second server must fail before recovery can touch this live row.
|
|
other, err := pipeline.Open(filepath.Join(r.store.Directory(), "test.db"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer other.Close()
|
|
if _, err := newRunner(ctx, other); err == nil || !strings.Contains(err.Error(), "another server owns") {
|
|
t.Fatalf("second server did not fail before recovery: %v", err)
|
|
}
|
|
detail, _ = r.store.GetRun(ctx, run.ID)
|
|
if detail.Status != "running" || detail.Steps[0].Status != "running" {
|
|
t.Fatal("second server recovered live execution", detail)
|
|
}
|
|
stopExecutor()
|
|
r.wg.Wait()
|
|
detail, err = r.store.GetRun(ctx, run.ID)
|
|
if err != nil || detail.Status != "canceled" || detail.Outcome != "" || detail.FinishedAt == "" || detail.Steps[0].Status != "canceled" {
|
|
t.Fatalf("late success beat stop: %+v %v", detail, err)
|
|
}
|
|
r.mu.Lock()
|
|
err = r.checkWorkspaceFree(workspace)
|
|
r.mu.Unlock()
|
|
if err != nil {
|
|
t.Fatal("confirmed stop did not release workspace", err)
|
|
}
|
|
}
|
|
|
|
func TestCleanupUnconfirmedReservesWorkspaceAcrossRecovery(t *testing.T) {
|
|
ctx := context.Background()
|
|
r, store, pipelineID := submitRunner(t, ctx, pipeline.Template([]string{"one"}, true))
|
|
path := filepath.Join(store.Directory(), "test.db")
|
|
defer func() { store.Close() }()
|
|
r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) {
|
|
return stage.Result{}, stage.ErrStageCleanup
|
|
}
|
|
workspace := t.TempDir()
|
|
request := protocol.Message{PipelineID: pipelineID, Version: 1, RequestKey: "cleanup", Workspace: workspace, Input: map[string]any{"prompt": "task"}}
|
|
run, err := r.start(request)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r.wg.Wait()
|
|
if err := r.cancel(run.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
detail, err := r.getRun(run.ID)
|
|
if err != nil || detail.Status != "running" || !detail.CleanupUnconfirmed || detail.FinishedAt != "" || !detail.Executing {
|
|
t.Fatalf("cleanup failure became terminal: %+v %v", detail, err)
|
|
}
|
|
request.RequestKey = "blocked"
|
|
if _, err := r.start(request); err == nil {
|
|
t.Fatal("unconfirmed cleanup released workspace")
|
|
}
|
|
if err := store.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
store, err = pipeline.Open(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
recovered, err := newRunner(ctx, store)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// No recoverable session pointer exists in this fixture: fail closed rather
|
|
// than claiming a restart proved an external process stopped.
|
|
if _, err := recovered.start(request); err == nil {
|
|
t.Fatal("restart released unconfirmed workspace without stop evidence")
|
|
}
|
|
detail, _ = recovered.getRun(run.ID)
|
|
if !detail.CleanupUnconfirmed || detail.Status != "running" || detail.FinishedAt != "" {
|
|
t.Fatal("recovery invented stop confirmation", detail)
|
|
}
|
|
}
|
|
|
|
func TestWorkspaceOverlapIncludesParentsDescendantsAndSymlinks(t *testing.T) {
|
|
_, r, pipelineID := concurrentStore(t)
|
|
workspace := t.TempDir()
|
|
child := filepath.Join(workspace, "child")
|
|
if err := os.Mkdir(child, 0700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
alias := filepath.Join(t.TempDir(), "alias")
|
|
if err := os.Symlink(child, alias); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) {
|
|
return stage.Result{}, nil
|
|
}
|
|
// Admission resolves aliases; the overlap check must cover both directions.
|
|
for _, pair := range [][2]string{{workspace, child}, {child, workspace}, {workspace, alias}} {
|
|
r.mu.Lock()
|
|
resolved, _ := filepath.EvalSymlinks(pair[0])
|
|
r.active[99] = activeRun{cancel: func() {}, workspace: resolved}
|
|
r.mu.Unlock()
|
|
_, err := r.start(protocol.Message{PipelineID: pipelineID, Version: 1, RequestKey: "overlap", Workspace: pair[1], Input: map[string]any{"prompt": "task"}})
|
|
if err == nil || !strings.Contains(err.Error(), "already active") {
|
|
t.Fatal("overlapping workspace admission", pair, err)
|
|
}
|
|
}
|
|
for _, pair := range [][2]string{{"/repo", "/repo-other"}, {"/repo/a", "/repo/b"}} {
|
|
if workspacesOverlap(pair[0], pair[1]) {
|
|
t.Fatal("sibling/prefix falsely overlaps", pair)
|
|
}
|
|
}
|
|
}
|