Files
pipelines/internal/server/execution_safety_test.go
T

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)
}
}
}