A container run only restored ownership of the bind-mounted worktree on the CommitAll/Push success path (archie-core#520). The agent runs as root inside the container, so every other way a run can end -- a gate failure that parks the task, a stage error, an early return -- left the worktree owned by UID 0 on the host. The daemon is the process that later cleans and resets that directory as its own non-root user, and it cannot even unlink inside a root-owned directory, so the next attempt failed before it could start no matter what the worktree refresh did. runTask now defers the same reconcileOwnership the commit and push paths already call, so it runs at every exit. The retry recoveries in worktree package cannot fix this from the daemon side: a non-root process cannot chown, and removing the directory needs write access to it. Observed through a supplementary group -- a non-root process may move a file it owns into a group it is a member of -- so the test proves the chown ran without needing root. Residual, filed as archie-core-zcg8: a container that is SIGKILLed never runs this defer.
771 lines
27 KiB
Go
771 lines
27 KiB
Go
package agentworker
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"log/slog"
|
|
"net"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"syscall"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/go-git/go-git/v6"
|
|
"github.com/nats-io/nats-server/v2/server"
|
|
natssrv "github.com/nats-io/nats-server/v2/test"
|
|
natsio "github.com/nats-io/nats.go"
|
|
"google.golang.org/grpc"
|
|
|
|
"github.com/samcharles93/archie-core/internal/agentexec"
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow"
|
|
"github.com/samcharles93/archie-core/internal/domain/workintake"
|
|
"github.com/samcharles93/archie-core/internal/events"
|
|
"github.com/samcharles93/archie-core/internal/forge"
|
|
"github.com/samcharles93/archie-core/internal/forgerpc"
|
|
agentnats "github.com/samcharles93/archie-core/internal/infrastructure/agenttransport/nats"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/staterpc"
|
|
"github.com/samcharles93/archie-core/internal/installtype"
|
|
"github.com/samcharles93/archie-core/internal/store"
|
|
"github.com/samcharles93/archie-core/internal/taskrun"
|
|
"github.com/samcharles93/archie-core/internal/worktree"
|
|
"github.com/samcharles93/archie-core/internal/worktreerpc"
|
|
)
|
|
|
|
// ── regression: archie-core#520 -- worktree ownership must be
|
|
// reconciled before push, since the agent commits as root inside the
|
|
// container and the daemon reads those same loose objects as its own
|
|
// non-root host user ──────────────────────────────────────────────────
|
|
|
|
type fakePushTrees struct {
|
|
pushed bool
|
|
pushErr error
|
|
}
|
|
|
|
func (f *fakePushTrees) Push(context.Context) error {
|
|
f.pushed = true
|
|
return f.pushErr
|
|
}
|
|
|
|
func TestWorktreeOwnerIDParsesEnvValue(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
env string
|
|
want int
|
|
}{
|
|
{"unset", "", -1},
|
|
{"zero is a valid uid (root)", "0", 0},
|
|
{"typical non-root uid", "1000", 1000},
|
|
{"garbage falls back to unset", "not-a-number", -1},
|
|
{"negative falls back to unset", "-1", -1},
|
|
}
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
if got := worktreeOwnerID(c.env); got != c.want {
|
|
t.Errorf("worktreeOwnerID(%q) = %d, want %d", c.env, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestHybridTreesPushReconcilesOwnershipWhenConfigured chowns to the test
|
|
// process's own uid/gid -- a permission no-op that succeeds without root --
|
|
// so this proves the walk runs and still reaches the underlying push,
|
|
// without needing privilege to chown to an arbitrary owner.
|
|
func TestHybridTreesPushReconcilesOwnershipWhenConfigured(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(dir, "file.txt"), []byte("x"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.MkdirAll(filepath.Join(dir, "sub"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "sub", "nested.txt"), []byte("y"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
fake := &fakePushTrees{}
|
|
trees := &hybridTrees{
|
|
push: fake,
|
|
localDir: dir,
|
|
worktreeUID: os.Getuid(),
|
|
worktreeGID: os.Getgid(),
|
|
}
|
|
|
|
if err := trees.Push(t.Context(), dir, "branch"); err != nil {
|
|
t.Fatalf("Push: %v", err)
|
|
}
|
|
if !fake.pushed {
|
|
t.Fatal("Push did not reach the underlying remote push")
|
|
}
|
|
}
|
|
|
|
// TestHybridTreesPushReconcilesOwnershipWithDanglingSymlink: a repo can
|
|
// legitimately track a symlink whose target doesn't exist inside the
|
|
// container (e.g. a relative link to something outside the checkout, or to
|
|
// a tool the image doesn't ship). Chowning must not follow it -- a
|
|
// following chown fails on a dangling target, which would abort a push
|
|
// that would otherwise have succeeded, a regression worse than the bug
|
|
// being fixed here.
|
|
func TestHybridTreesPushReconcilesOwnershipWithDanglingSymlink(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if err := os.Symlink(filepath.Join(dir, "does-not-exist"), filepath.Join(dir, "broken-link")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
fake := &fakePushTrees{}
|
|
trees := &hybridTrees{
|
|
push: fake,
|
|
localDir: dir,
|
|
worktreeUID: os.Getuid(),
|
|
worktreeGID: os.Getgid(),
|
|
}
|
|
|
|
if err := trees.Push(t.Context(), dir, "branch"); err != nil {
|
|
t.Fatalf("Push: %v", err)
|
|
}
|
|
if !fake.pushed {
|
|
t.Fatal("Push did not reach the underlying remote push")
|
|
}
|
|
}
|
|
|
|
// TestHybridTreesPushSkipsReconciliationWhenNotConfigured: an unset
|
|
// WORKTREE_UID/GID (archie-core's non-container and test callers) must not
|
|
// attempt any chown at all -- a nonexistent dir would otherwise fail the
|
|
// walk, so this proves the walk is skipped entirely, not just tolerant of
|
|
// this one input.
|
|
func TestHybridTreesPushSkipsReconciliationWhenNotConfigured(t *testing.T) {
|
|
fake := &fakePushTrees{}
|
|
trees := &hybridTrees{
|
|
push: fake,
|
|
localDir: filepath.Join(t.TempDir(), "does-not-exist"),
|
|
worktreeUID: -1,
|
|
worktreeGID: -1,
|
|
}
|
|
|
|
if err := trees.Push(t.Context(), trees.localDir, "branch"); err != nil {
|
|
t.Fatalf("Push: %v", err)
|
|
}
|
|
if !fake.pushed {
|
|
t.Fatal("Push did not reach the underlying remote push")
|
|
}
|
|
}
|
|
|
|
func TestHybridTreesCommitReconcilesOwnershipEvenWhenCommitFails(t *testing.T) {
|
|
missing := filepath.Join(t.TempDir(), "does-not-exist")
|
|
trees := &hybridTrees{
|
|
local: &worktree.Manager{},
|
|
localDir: missing,
|
|
worktreeUID: os.Getuid(),
|
|
worktreeGID: os.Getgid(),
|
|
}
|
|
|
|
_, err := trees.CommitAll(t.Context(), missing, "test commit")
|
|
if err == nil {
|
|
t.Fatal("CommitAll error = nil, want commit and ownership reconciliation failure")
|
|
}
|
|
if !strings.Contains(err.Error(), "reconcile worktree ownership after commit") {
|
|
t.Fatalf("CommitAll error = %q, want ownership reconciliation context", err)
|
|
}
|
|
}
|
|
|
|
// TestHybridTreesPushSurfacesOwnershipReconciliationFailure: a configured
|
|
// but broken reconciliation (the dir push is asked to fix vanished) must
|
|
// fail loudly rather than forward to a push that will only fail later with
|
|
// a much more confusing git-internal permission error.
|
|
func TestHybridTreesPushSurfacesOwnershipReconciliationFailure(t *testing.T) {
|
|
fake := &fakePushTrees{}
|
|
missing := filepath.Join(t.TempDir(), "does-not-exist")
|
|
trees := &hybridTrees{
|
|
push: fake,
|
|
localDir: missing,
|
|
worktreeUID: os.Getuid(),
|
|
worktreeGID: os.Getgid(),
|
|
}
|
|
|
|
err := trees.Push(t.Context(), missing, "branch")
|
|
if err == nil {
|
|
t.Fatal("expected an error reconciling ownership of a missing directory")
|
|
}
|
|
if fake.pushed {
|
|
t.Fatal("Push must not reach the underlying remote push when reconciliation fails")
|
|
}
|
|
}
|
|
|
|
// TestApplyToolLimitsWiresConfiguredPolicyIntoLoopRunner guards against
|
|
// regressing archie-core's tool-result cap and spill dir back to inert
|
|
// zero values on the worker path (agentexec-1 / tools-core-11): a
|
|
// *LoopRunner built for a task must carry the daemon's configured
|
|
// ToolPolicy, not the zero value NewLoopRunner leaves it at.
|
|
func TestApplyToolLimitsWiresConfiguredPolicyIntoLoopRunner(t *testing.T) {
|
|
runner := agentexec.NewLoopRunner(agentexec.NewRuntime(nil), slog.New(slog.DiscardHandler))
|
|
policy := config.ToolPolicy{MaxResultChars: 12345, SpillDir: "/var/tmp/archie-spill"}
|
|
|
|
applyToolLimits(runner, policy)
|
|
|
|
want := agentexec.ToolLimits{MaxResultChars: 12345, SpillDir: "/var/tmp/archie-spill"}
|
|
if runner.Limits != want {
|
|
t.Fatalf("runner.Limits = %+v, want %+v", runner.Limits, want)
|
|
}
|
|
}
|
|
|
|
// TestApplyToolLimitsIgnoresNonLoopRunner confirms a test-fake runner (which
|
|
// is not a *agentexec.LoopRunner) is left untouched rather than panicking.
|
|
func TestApplyToolLimitsIgnoresNonLoopRunner(t *testing.T) {
|
|
applyToolLimits(panicRunner{t}, config.ToolPolicy{MaxResultChars: 1})
|
|
}
|
|
|
|
type panicRunner struct{ t *testing.T }
|
|
|
|
func (r panicRunner) Run(context.Context, string, agentexec.Request, agentexec.ToolCallReporter) (agentexec.Result, error) {
|
|
r.t.Fatal("bootstrap workflow must not invoke an LLM runner")
|
|
return agentexec.Result{}, nil
|
|
}
|
|
|
|
type prCapturingForge struct {
|
|
prs []struct{ owner, repo, title, head, base, body string }
|
|
}
|
|
|
|
func (f *prCapturingForge) Comment(context.Context, string, string, int, string) (int64, error) {
|
|
return 1, nil
|
|
}
|
|
|
|
func (f *prCapturingForge) CloseIssue(context.Context, string, string, int, string) error { return nil }
|
|
|
|
func (f *prCapturingForge) CreatePR(_ context.Context, owner, repo, title, head, base, body string) (int, error) {
|
|
f.prs = append(f.prs, struct{ owner, repo, title, head, base, body string }{owner, repo, title, head, base, body})
|
|
return 5, nil
|
|
}
|
|
func (f *prCapturingForge) SetStateLabel(context.Context, string, string, int, string, []string) {}
|
|
func (f *prCapturingForge) AcceptInvitations(context.Context) error { panic("unexpected call") }
|
|
|
|
func (f *prCapturingForge) AssignedIssues(context.Context, string, string, string) ([]forge.Issue, error) {
|
|
panic("unexpected call")
|
|
}
|
|
|
|
func (f *prCapturingForge) IssuesWithLabel(context.Context, string, string, string) ([]forge.Issue, error) {
|
|
panic("unexpected call")
|
|
}
|
|
|
|
func (f *prCapturingForge) PRState(context.Context, string, string, int) (string, error) {
|
|
panic("unexpected call")
|
|
}
|
|
|
|
func (f *prCapturingForge) CreateIssue(context.Context, string, string, string, string, []string) (int, error) {
|
|
panic("unexpected call")
|
|
}
|
|
|
|
func (f *prCapturingForge) React(context.Context, string, string, int, string) error {
|
|
panic("unexpected call")
|
|
}
|
|
|
|
func (f *prCapturingForge) VerifyPush(context.Context, string, string) error {
|
|
panic("unexpected call")
|
|
}
|
|
|
|
func (f *prCapturingForge) LinkBranch(context.Context, string, string, int, string) error { return nil }
|
|
|
|
type remoteManager struct {
|
|
manager *worktree.Manager
|
|
dir string
|
|
branch string
|
|
}
|
|
|
|
func (r *remoteManager) Prepare(ctx context.Context, owner, repo, base string, issue int, title, body, labels string) (string, string, error) {
|
|
dir, branch, err := r.manager.Prepare(ctx, owner, repo, base, issue, title, body, labels)
|
|
if err == nil {
|
|
r.dir = dir
|
|
r.branch = branch
|
|
}
|
|
return dir, branch, err
|
|
}
|
|
|
|
func (r *remoteManager) Push(ctx context.Context) error {
|
|
return r.manager.Push(ctx, r.dir, r.branch)
|
|
}
|
|
|
|
func newLocalRemote(t *testing.T, owner, repo string) string {
|
|
t.Helper()
|
|
host := t.TempDir()
|
|
bare := filepath.Join(host, owner, repo+".git")
|
|
seed := filepath.Join(t.TempDir(), "seed")
|
|
run := func(dir string, args ...string) {
|
|
t.Helper()
|
|
cmd := exec.CommandContext(t.Context(), "git", args...)
|
|
cmd.Dir = dir
|
|
cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0")
|
|
if out, err := cmd.CombinedOutput(); err != nil {
|
|
t.Fatalf("git %v: %v\n%s", args, err, out)
|
|
}
|
|
}
|
|
if err := os.MkdirAll(bare, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
run(host, "init", "--bare", "-b", "main", bare)
|
|
if err := os.MkdirAll(seed, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
run(seed, "init", "-b", "main")
|
|
run(seed, "config", "user.name", "seeder")
|
|
run(seed, "config", "user.email", "seed@example.com")
|
|
if err := os.WriteFile(filepath.Join(seed, "README.md"), []byte("seed\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
run(seed, "add", "-A")
|
|
run(seed, "commit", "-m", "seed")
|
|
run(seed, "push", "file://"+bare, "main")
|
|
return host
|
|
}
|
|
|
|
func startEmbeddedTaskRPCServer(t *testing.T) *server.Server {
|
|
t.Helper()
|
|
srv := natssrv.RunRandClientPortServer()
|
|
t.Cleanup(srv.Shutdown)
|
|
if err := srv.EnableJetStream(&server.JetStreamConfig{StoreDir: t.TempDir()}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return srv
|
|
}
|
|
|
|
func connectTaskRPC(t *testing.T, url string) *natsio.Conn {
|
|
t.Helper()
|
|
connection, err := natsio.Connect(url)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(connection.Close)
|
|
return connection
|
|
}
|
|
|
|
// startStateStoreGRPC serves the State Store gRPC contract over a loopback
|
|
// TCP listener fronting local, returning the dial address. The agent is fully
|
|
// on gRPC for its store calls (docs/prds/state-store-contract.md §12 step 4),
|
|
// so an agentworker test that drives executeTaskRequest needs a real State
|
|
// Store server rather than the deleted NATS storerpc path.
|
|
func startStateStoreGRPC(t *testing.T, local *store.Store) string {
|
|
t.Helper()
|
|
listener, err := (&net.ListenConfig{}).Listen(t.Context(), "tcp", "127.0.0.1:0")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
server := grpc.NewServer()
|
|
staterpc.RegisterServer(server, staterpc.Deps{
|
|
Tasks: local, Captures: local, Mappings: local, Bindings: local,
|
|
BindingDispatcher: local, BindingTaskCreator: local,
|
|
})
|
|
go func() { _ = server.Serve(listener) }()
|
|
t.Cleanup(func() { server.Stop(); _ = listener.Close() })
|
|
return listener.Addr().String()
|
|
}
|
|
|
|
func TestRunTaskExecutesBootstrapWorkflowEndToEnd(t *testing.T) {
|
|
if _, err := exec.LookPath("git"); err != nil {
|
|
t.Skip("git not installed")
|
|
}
|
|
ctx := t.Context()
|
|
host := newLocalRemote(t, "acme", "widget")
|
|
st := store.OpenTest(t)
|
|
if _, err := st.EnqueueIssue(ctx, "acme", "widget", 1, "feat: bootstrap test", "", "bootstrap", ""); err != nil {
|
|
t.Fatalf("enqueue: %v", err)
|
|
}
|
|
task, err := st.ClaimNext(ctx)
|
|
if err != nil || task == nil {
|
|
t.Fatalf("claim: (%v, %v)", task, err)
|
|
}
|
|
fg := &prCapturingForge{}
|
|
manager := &worktree.Manager{WorkDir: t.TempDir(), Token: "unused", BotUser: "archie-bot", BotEmail: "archie-bot@example.com", BaseURL: "file://" + host}
|
|
remote := &remoteManager{manager: manager}
|
|
hostDir, _, err := remote.Prepare(ctx, "acme", "widget", "main", 1, task.Title, "", "bootstrap")
|
|
if err != nil {
|
|
t.Fatalf("prepare: %v", err)
|
|
}
|
|
req := taskrun.Request{
|
|
Task: task,
|
|
Repo: config.Repo{Owner: "acme", Name: "widget", Base: "main"},
|
|
Cfg: config.Config{BotUser: "archie-bot", BotEmail: "archie-bot@example.com"}.ForTask(),
|
|
}
|
|
fakeRunner := runnerFactory(func(map[string]agentexec.Provider, *slog.Logger) agentexec.Runner { return panicRunner{t} })
|
|
response, err := runTask(ctx, req, taskDependencies{forge: fg, store: st, trees: remote}, fakeRunner, hostDir, slog.New(slog.DiscardHandler))
|
|
if err != nil {
|
|
t.Fatalf("runTask: %v", err)
|
|
}
|
|
if response.Status != workflow.StatusPROpen || len(fg.prs) != 1 {
|
|
t.Fatalf("response status/PRs = (%q, %d), want (%q, 1)", response.Status, len(fg.prs), workflow.StatusPROpen)
|
|
}
|
|
stored, err := st.TaskByIssue(ctx, "acme", "widget", 1)
|
|
if err != nil || stored == nil || stored.Status != workflow.StatusPROpen || stored.PRNumber != 5 {
|
|
t.Fatalf("stored task = (%+v, %v), want PR-open task #5", stored, err)
|
|
}
|
|
if _, err := os.Stat(filepath.Join(hostDir, ".archie", "bootstrap.md")); err != nil {
|
|
t.Fatalf("expected bootstrap marker file: %v", err)
|
|
}
|
|
repo, err := git.PlainOpen(hostDir)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
head, err := repo.Head()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
commit, err := repo.CommitObject(head.Hash())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if commit.Author.Name != "archie-bot" || commit.Author.Email != "archie-bot@example.com" ||
|
|
commit.Committer.Name != "archie-bot" || commit.Committer.Email != "archie-bot@example.com" {
|
|
t.Fatalf("commit identity = author %q <%s>, committer %q <%s>",
|
|
commit.Author.Name, commit.Author.Email, commit.Committer.Name, commit.Committer.Email)
|
|
}
|
|
}
|
|
|
|
// TestRunTaskRestoresWorktreeOwnershipOnEveryExit pins the half of the
|
|
// worktree-ownership contract that archie-core#520 left open. CommitAll and
|
|
// Push hand the worktree back to the daemon's own UID on the SUCCESS path;
|
|
// every other way a container run can end -- a gate failure that parks the
|
|
// task, a stage error, an early return -- used to leave the worktree owned by
|
|
// root, because the agent runs as root inside the container. The daemon then
|
|
// could not clean or reset those paths on the next attempt (a root-owned
|
|
// directory cannot be unlinked from by its non-root owner), so a retry failed
|
|
// before it could start no matter what the worktree refresh did.
|
|
//
|
|
// The run below exits early, which is the point: the restore has to be
|
|
// deferred over the whole run rather than attached to the paths that happen to
|
|
// commit. It is observed through a supplementary group -- a non-root process
|
|
// may move a file it owns into a group it is a member of, so this proves the
|
|
// chown ran without needing root.
|
|
func TestRunTaskRestoresWorktreeOwnershipOnEveryExit(t *testing.T) {
|
|
probeGroup := supplementaryGroup(t)
|
|
workDir := t.TempDir()
|
|
probe := filepath.Join(workDir, "probe.txt")
|
|
if err := os.WriteFile(probe, []byte("x\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
t.Setenv("WORKTREE_UID", strconv.Itoa(os.Getuid()))
|
|
t.Setenv("WORKTREE_GID", strconv.Itoa(probeGroup))
|
|
|
|
// A runner factory that yields nothing fails the run after the trees (and
|
|
// the ownership defer) are already in place.
|
|
_, err := runTask(t.Context(), taskrun.Request{
|
|
Task: &workflow.Task{ID: 77, Branch: "feat/77-probe", Workflow: "implement"},
|
|
Repo: config.Repo{Owner: "acme", Name: "widget", Base: "main"},
|
|
}, taskDependencies{}, runnerFactory(func(map[string]agentexec.Provider, *slog.Logger) agentexec.Runner {
|
|
return nil
|
|
}), workDir, slog.New(slog.DiscardHandler))
|
|
if err == nil {
|
|
t.Fatal("runTask error = nil, want the missing-runner failure this exit is built around")
|
|
}
|
|
|
|
info, statErr := os.Stat(probe)
|
|
if statErr != nil {
|
|
t.Fatal(statErr)
|
|
}
|
|
gid, ok := info.Sys().(*syscall.Stat_t)
|
|
if !ok {
|
|
t.Fatal("no syscall.Stat_t for the ownership probe")
|
|
}
|
|
if int(gid.Gid) != probeGroup {
|
|
t.Errorf("probe.txt gid = %d, want %d -- a run that never reached CommitAll or Push left the worktree owned by the container's own user", gid.Gid, probeGroup)
|
|
}
|
|
}
|
|
|
|
// supplementaryGroup returns a group this process is a member of but that is
|
|
// not its primary gid, so a test can observe a chown a non-root process is
|
|
// allowed to make.
|
|
func supplementaryGroup(t *testing.T) int {
|
|
t.Helper()
|
|
groups, err := os.Getgroups()
|
|
if err != nil {
|
|
t.Skipf("os.Getgroups: %v", err)
|
|
}
|
|
for _, gid := range groups {
|
|
if gid != os.Getgid() {
|
|
return gid
|
|
}
|
|
}
|
|
t.Skip("process belongs to no supplementary group to chown into")
|
|
return 0
|
|
}
|
|
|
|
// TestExecuteTaskRequestUsesInfrastructureRPCDependencies preserves the
|
|
// application-to-infrastructure proof: the application asks Transport for its
|
|
// forge/store/tree contracts, and those concrete clients cross embedded NATS
|
|
// to daemon-side RPC servers before the bootstrap workflow can complete.
|
|
func TestExecuteTaskRequestUsesInfrastructureRPCDependencies(t *testing.T) {
|
|
if _, err := exec.LookPath("git"); err != nil {
|
|
t.Skip("git not installed")
|
|
}
|
|
ctx := t.Context()
|
|
host := newLocalRemote(t, "acme", "rpc-widget")
|
|
st := store.OpenTest(t)
|
|
if _, err := st.EnqueueIssue(ctx, "acme", "rpc-widget", 2, "feat: RPC bootstrap test", "", "bootstrap", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, err := st.ClaimNext(ctx)
|
|
if err != nil || task == nil {
|
|
t.Fatalf("claim = (%+v, %v)", task, err)
|
|
}
|
|
forge := &prCapturingForge{}
|
|
daemonTrees := &worktree.Manager{
|
|
WorkDir: t.TempDir(),
|
|
Token: "unused-for-file-remotes",
|
|
BotUser: "archie-bot",
|
|
BotEmail: "archie-bot@example.com",
|
|
BaseURL: "file://" + host,
|
|
}
|
|
hostDir, branch, err := daemonTrees.Prepare(ctx, "acme", "rpc-widget", "main", 2, task.Title, "", "bootstrap")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task.Branch = branch
|
|
grants := worktreerpc.NewGrants()
|
|
grant, revokeGrant, err := grants.Issue(task)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(revokeGrant)
|
|
|
|
srv := startEmbeddedTaskRPCServer(t)
|
|
serverConn := connectTaskRPC(t, srv.ClientURL())
|
|
unsubForge, err := (&forgerpc.Server{Forge: forge, Log: slog.New(slog.DiscardHandler)}).Register(serverConn)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(unsubForge)
|
|
unsubTrees, err := (&worktreerpc.Server{Trees: daemonTrees, Grants: grants, Log: slog.New(slog.DiscardHandler)}).Register(serverConn)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(unsubTrees)
|
|
|
|
transport, err := agentnats.Connect(ctx, agentnats.Config{URL: srv.ClientURL(), StateStoreURL: startStateStoreGRPC(t, st)}, slog.New(slog.DiscardHandler))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(transport.Close)
|
|
|
|
request := taskrun.Request{
|
|
Task: task,
|
|
Repo: config.Repo{Owner: "acme", Name: "rpc-widget", Base: "main"},
|
|
Cfg: config.Config{}.ForTask(),
|
|
WorktreeGrant: grant,
|
|
}
|
|
response, err := executeTaskRequest(ctx, request, transport, hostDir, slog.New(slog.DiscardHandler))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Status != workflow.StatusPROpen || len(forge.prs) != 1 {
|
|
t.Fatalf("response status/PRs = (%q, %d), want (%q, 1)", response.Status, len(forge.prs), workflow.StatusPROpen)
|
|
}
|
|
// archie-core-1786751948782-3-837a8fd0 point 4: every response reports
|
|
// what this worker actually is, since it's the only channel the daemon
|
|
// has to learn what's really running (see daemon.AgentStatus).
|
|
if response.AgentVersion != Version() {
|
|
t.Errorf("response.AgentVersion = %q, want Version() = %q", response.AgentVersion, Version())
|
|
}
|
|
if response.AgentInstallType != installtype.Type() {
|
|
t.Errorf("response.AgentInstallType = %q, want installtype.Type() = %q", response.AgentInstallType, installtype.Type())
|
|
}
|
|
stored, err := st.TaskByIssue(ctx, "acme", "rpc-widget", 2)
|
|
if err != nil || stored == nil || stored.Status != workflow.StatusPROpen || stored.PRNumber != 5 {
|
|
t.Fatalf("stored task = (%+v, %v), want RPC-persisted PR-open task #5", stored, err)
|
|
}
|
|
if _, err := os.Stat(filepath.Join(hostDir, ".archie", "bootstrap.md")); err != nil {
|
|
t.Fatalf("expected bootstrap marker file: %v", err)
|
|
}
|
|
}
|
|
|
|
// TestExecuteTaskRequestForwardsWorkflowEventsOverNATS is the regression test
|
|
// for the "No events yet" dashboard bug (archie-core-518): a workflow run
|
|
// through the NATS/container path publishes its stage/outcome events to an
|
|
// in-process *events.Bus nothing on the daemon side could see, because
|
|
// runTask never wired TaskContext.Bus. This proves the fix end to end -- a
|
|
// bystander subscribed directly to SubjectForEvents(task.ID) on the same
|
|
// embedded NATS server executeTaskRequest uses receives real events the
|
|
// bootstrap workflow emits, exactly as the daemon's own subscriber would.
|
|
func TestExecuteTaskRequestForwardsWorkflowEventsOverNATS(t *testing.T) {
|
|
if _, err := exec.LookPath("git"); err != nil {
|
|
t.Skip("git not installed")
|
|
}
|
|
ctx := t.Context()
|
|
host := newLocalRemote(t, "acme", "events-widget")
|
|
st := store.OpenTest(t)
|
|
if _, err := st.EnqueueIssue(ctx, "acme", "events-widget", 3, "feat: events bootstrap test", "", "bootstrap", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, err := st.ClaimNext(ctx)
|
|
if err != nil || task == nil {
|
|
t.Fatalf("claim = (%+v, %v)", task, err)
|
|
}
|
|
forge := &prCapturingForge{}
|
|
daemonTrees := &worktree.Manager{
|
|
WorkDir: t.TempDir(),
|
|
Token: "unused-for-file-remotes",
|
|
BotUser: "archie-bot",
|
|
BotEmail: "archie-bot@example.com",
|
|
BaseURL: "file://" + host,
|
|
}
|
|
hostDir, branch, err := daemonTrees.Prepare(ctx, "acme", "events-widget", "main", 3, task.Title, "", "bootstrap")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task.Branch = branch
|
|
grants := worktreerpc.NewGrants()
|
|
grant, revokeGrant, err := grants.Issue(task)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(revokeGrant)
|
|
|
|
srv := startEmbeddedTaskRPCServer(t)
|
|
serverConn := connectTaskRPC(t, srv.ClientURL())
|
|
unsubForge, err := (&forgerpc.Server{Forge: forge, Log: slog.New(slog.DiscardHandler)}).Register(serverConn)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(unsubForge)
|
|
unsubTrees, err := (&worktreerpc.Server{Trees: daemonTrees, Grants: grants, Log: slog.New(slog.DiscardHandler)}).Register(serverConn)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(unsubTrees)
|
|
|
|
// Stand in for the daemon's own SubjectEventsWildcard subscriber: bind
|
|
// to the exact per-task subject before the workflow runs, so nothing
|
|
// published during the run can be missed.
|
|
var (
|
|
mu sync.Mutex
|
|
received []events.Event
|
|
)
|
|
bystander := connectTaskRPC(t, srv.ClientURL())
|
|
eventSub, err := bystander.Subscribe(agentexec.SubjectForEvents(task.ID), func(msg *natsio.Msg) {
|
|
var e events.Event
|
|
if err := json.Unmarshal(msg.Data, &e); err != nil {
|
|
t.Errorf("undecodable event message: %v", err)
|
|
return
|
|
}
|
|
mu.Lock()
|
|
received = append(received, e)
|
|
mu.Unlock()
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = eventSub.Unsubscribe() })
|
|
if err := bystander.Flush(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
transport, err := agentnats.Connect(ctx, agentnats.Config{URL: srv.ClientURL(), StateStoreURL: startStateStoreGRPC(t, st)}, slog.New(slog.DiscardHandler))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(transport.Close)
|
|
|
|
request := taskrun.Request{
|
|
Task: task,
|
|
Repo: config.Repo{Owner: "acme", Name: "events-widget", Base: "main"},
|
|
Cfg: config.Config{}.ForTask(),
|
|
WorktreeGrant: grant,
|
|
}
|
|
response, err := executeTaskRequest(ctx, request, transport, hostDir, slog.New(slog.DiscardHandler))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Status != workflow.StatusPROpen {
|
|
t.Fatalf("response status = %q, want %q", response.Status, workflow.StatusPROpen)
|
|
}
|
|
|
|
deadline := time.After(2 * time.Second)
|
|
for {
|
|
mu.Lock()
|
|
sawOutcome := false
|
|
for _, e := range received {
|
|
if e.Kind == events.KindOutcome {
|
|
sawOutcome = true
|
|
break
|
|
}
|
|
}
|
|
mu.Unlock()
|
|
if sawOutcome {
|
|
break
|
|
}
|
|
select {
|
|
case <-deadline:
|
|
t.Fatal("no \"outcome\" event arrived on SubjectForEvents(task.ID) within 2s")
|
|
case <-time.After(10 * time.Millisecond):
|
|
}
|
|
}
|
|
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
sawOutcome := false
|
|
for _, e := range received {
|
|
if e.TaskID != task.ID {
|
|
t.Errorf("event %+v carries TaskID %d, want %d", e, e.TaskID, task.ID)
|
|
}
|
|
if e.Kind == events.KindOutcome {
|
|
sawOutcome = true
|
|
}
|
|
}
|
|
if !sawOutcome {
|
|
t.Errorf("received %d events %+v, want at least one %q", len(received), received, events.KindOutcome)
|
|
}
|
|
}
|
|
|
|
// TestRouteTaskUsesRequestKindOverride is the regression for
|
|
// workflow-engine-1: a kind -> workflow override loaded by the daemon is
|
|
// carried in the taskrun request and applied by the worker process, so
|
|
// workflow.Route honours it instead of silently falling back to the
|
|
// built-in default (bug -> tdd).
|
|
func TestRouteTaskUsesRequestKindOverride(t *testing.T) {
|
|
t.Cleanup(func() {
|
|
workflow.SetKindWorkflows(nil)
|
|
workflow.SetLabelWorkflows(nil)
|
|
})
|
|
|
|
registry := workflow.Registry{
|
|
"tdd": workflow.Workflow{Name: "tdd"},
|
|
"bootstrap": workflow.Workflow{Name: "bootstrap"},
|
|
"implement": workflow.Workflow{Name: "implement"},
|
|
}
|
|
req := taskrun.Request{
|
|
Task: &workflow.Task{Labels: "bug"},
|
|
KindWorkflows: workflow.KindWorkflows{workintake.KindBug: "bootstrap"},
|
|
}
|
|
|
|
wf := routeTask(req, registry)
|
|
if wf.Name != "bootstrap" {
|
|
t.Fatalf("routeTask() = %q, want %q (request kind override not applied)", wf.Name, "bootstrap")
|
|
}
|
|
}
|
|
|
|
// TestRouteTaskUsesRequestLabelOverride is the label counterpart: an
|
|
// arbitrary-label binding carried in the request also reaches the worker's
|
|
// routing decision.
|
|
func TestRouteTaskUsesRequestLabelOverride(t *testing.T) {
|
|
t.Cleanup(func() {
|
|
workflow.SetKindWorkflows(nil)
|
|
workflow.SetLabelWorkflows(nil)
|
|
})
|
|
|
|
registry := workflow.Registry{
|
|
"implement": workflow.Workflow{Name: "implement"},
|
|
"security-review": workflow.Workflow{Name: "security-review"},
|
|
}
|
|
req := taskrun.Request{
|
|
Task: &workflow.Task{Labels: "security"},
|
|
LabelWorkflows: workflow.LabelWorkflows{"security": "security-review"},
|
|
}
|
|
|
|
wf := routeTask(req, registry)
|
|
if wf.Name != "security-review" {
|
|
t.Fatalf("routeTask() = %q, want %q (request label override not applied)", wf.Name, "security-review")
|
|
}
|
|
}
|