* refactor(state-store): delete NATS storerpc; agent store is gRPC-only (archie-core-8cda.4.6) The agent is fully on the gRPC State Store contract, so the legacy NATS storerpc path is dead (docs/prds/state-store-contract.md §12 step 4): - delete internal/storerpc (Server, Client, subjects) and its tests - drop the storerpc registration from registerTaskRPCServers and the now-unused store param - make the agent transport's State Store URL required and Store() return only the gRPC staterpc.Client (no NATS fallback) - rework agentworker/agent transport tests to back the store with a real gRPC State Store server instead of the deleted NATS storerpc server The agent binary now fails fast when STATE_STORE_URL is absent. Agent store calls (workflow.Store) go over gRPC to the archie-state-store service. * refactor(state-store): delete daemon/gateway in-process store ownership (archie-core-8cda.4.6) The daemon and gateway no longer open archie.db in-process: the single SQLite file is owned by the standalone archie-state-store process, and both consumers dial its gRPC State StateStore contract (docs/prds/state-store-contract.md §12 step 7, no dual-store ownership). - openStores no longer opens the production task store or seeds b.st; it only wires secrets/forge and the gateway conversation store - openStateStoreAdapter now requires [services.state].target (the old local default is deleted) and resolves b.stateStore as the remote *staterpc.Client - delete the in-process startStateStoreServer (the multiplexed gRPC server and its per-task bearer-token registry) from the daemon composition - RunGateway now resolves the same remote State Store adapter; its session SQLite stays Gateway-owned and untouched - daemon.ConnectedStateStore carries the configured target plus the resolved bearer token, which containerEnv injects as STATE_STORE_URL / STATE_STORE_TOKEN so archie-agent authenticates to the same remote service - readiness store probe reads b.stateStore PRD-consistent choice (noted): with the in-process server gone, per-task token generation is removed; the daemon/gateway/agent all present the single [services.state].target_token (or STATE_STORE_TOKEN secret) that the standalone store validates. * docs(webui): require [services.state].target in config and deployment templates (archie-core-8cda.4.6) After the in-process store path is deleted, archied and archie-gateway dial the standalone archie-state-store gRPC service via [services.state].target and never open archie.db themselves (docs/prds/state-store-contract.md §12 step 7). - config.example.toml documents [services.state].target as required, with the loopback vs Docker-bridge gateway + target_token rule - deployment templates set [services.state] per topology: bridge gateway + token for container-mode agents, loopback for host-only - deployments/README.md and systemd-user-service.md describe start commands for both topologies and drop the stale "not yet consumed by the daemon" note * style: gofumpt alignment for State Store daemon literal; appease noctx/staticcheck (archie-core-8cda.4.6) * docs(state-store): refresh stale in-process references post-cutover (archie-core-8cda.4.6)
344 lines
9.6 KiB
Go
344 lines
9.6 KiB
Go
package daemon
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"log/slog"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/go-git/go-git/v6"
|
|
gitconfig "github.com/go-git/go-git/v6/config"
|
|
"github.com/go-git/go-git/v6/plumbing"
|
|
"github.com/go-git/go-git/v6/plumbing/object"
|
|
dockercontainer "github.com/moby/moby/api/types/container"
|
|
"github.com/moby/moby/client"
|
|
natsio "github.com/nats-io/nats.go"
|
|
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
archiecontainer "github.com/samcharles93/archie-core/internal/container"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow"
|
|
agentnats "github.com/samcharles93/archie-core/internal/infrastructure/agenttransport/nats"
|
|
"github.com/samcharles93/archie-core/internal/storage"
|
|
"github.com/samcharles93/archie-core/internal/store"
|
|
"github.com/samcharles93/archie-core/internal/taskrun"
|
|
"github.com/samcharles93/archie-core/internal/worktree"
|
|
)
|
|
|
|
type noopStorage struct{}
|
|
|
|
func (s *noopStorage) Setup(context.Context, storage.TaskRef) ([]storage.Mount, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (s *noopStorage) Teardown(context.Context, storage.TaskRef) error {
|
|
return nil
|
|
}
|
|
|
|
func (s *noopStorage) CleanupExpired(context.Context, time.Duration) (int, error) {
|
|
return 0, nil
|
|
}
|
|
|
|
func newLocalRemote(t *testing.T, owner, repo string) string {
|
|
t.Helper()
|
|
host := t.TempDir()
|
|
bare := filepath.Join(host, owner, repo+".git")
|
|
mainRef := plumbing.NewBranchReferenceName("main")
|
|
|
|
if _, err := git.PlainInit(bare, true, git.WithDefaultBranch(mainRef)); err != nil {
|
|
t.Fatalf("init bare remote: %v", err)
|
|
}
|
|
|
|
seed := filepath.Join(t.TempDir(), "seed")
|
|
sr, err := git.PlainInit(seed, false, git.WithDefaultBranch(mainRef))
|
|
if err != nil {
|
|
t.Fatalf("init seed repo: %v", err)
|
|
}
|
|
cfg, err := sr.Config()
|
|
if err != nil {
|
|
t.Fatalf("read seed config: %v", err)
|
|
}
|
|
cfg.Raw.Section("commit").SetOption("gpgsign", "false")
|
|
if err := sr.SetConfig(cfg); err != nil {
|
|
t.Fatalf("write seed config: %v", err)
|
|
}
|
|
|
|
if err := os.WriteFile(filepath.Join(seed, "README.md"), []byte("seed\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
wt, err := sr.Worktree()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := wt.Add("README.md"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
sig := &object.Signature{Name: "test", Email: "test@test", When: time.Now()}
|
|
h, err := wt.Commit("seed", &git.CommitOptions{Author: sig, Committer: sig})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if _, err := sr.CreateRemote(&gitconfig.RemoteConfig{
|
|
Name: git.DefaultRemoteName,
|
|
URLs: []string{bare},
|
|
}); err != nil {
|
|
t.Fatalf("create remote: %v", err)
|
|
}
|
|
if err := sr.PushContext(t.Context(), &git.PushOptions{
|
|
RemoteName: git.DefaultRemoteName,
|
|
RefSpecs: []gitconfig.RefSpec{gitconfig.RefSpec(mainRef + ":" + mainRef)},
|
|
}); err != nil {
|
|
t.Fatalf("push seed to bare remote: %v", err)
|
|
}
|
|
_ = h
|
|
return host
|
|
}
|
|
|
|
func TestCleanupTerminalTaskWorktreeLifecycle(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
taskIdentity string
|
|
setupStatus string
|
|
prNumber int
|
|
wantTreeExists bool
|
|
}{
|
|
{
|
|
name: "root no-change merged task cleans worktree",
|
|
taskIdentity: "",
|
|
setupStatus: workflow.StatusMerged,
|
|
prNumber: 0,
|
|
wantTreeExists: false,
|
|
},
|
|
{
|
|
name: "multi-identity no-change merged task cleans identity worktree",
|
|
taskIdentity: "winter",
|
|
setupStatus: workflow.StatusMerged,
|
|
prNumber: 0,
|
|
wantTreeExists: false,
|
|
},
|
|
{
|
|
name: "parked task preserves worktree for post-mortem",
|
|
taskIdentity: "",
|
|
setupStatus: workflow.StatusParked,
|
|
prNumber: 0,
|
|
wantTreeExists: true,
|
|
},
|
|
{
|
|
name: "open PR task preserves worktree for PR reconciliation",
|
|
taskIdentity: "",
|
|
setupStatus: workflow.StatusPROpen,
|
|
prNumber: 42,
|
|
wantTreeExists: true,
|
|
},
|
|
{
|
|
name: "waiting human task preserves worktree",
|
|
taskIdentity: "",
|
|
setupStatus: workflow.StatusWaitingHuman,
|
|
prNumber: 0,
|
|
wantTreeExists: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
ctx := context.Background()
|
|
st := store.OpenTest(t)
|
|
t.Cleanup(func() { _ = st.Close() })
|
|
|
|
rootTrees := &worktree.Manager{WorkDir: t.TempDir()}
|
|
winterTrees := &worktree.Manager{WorkDir: t.TempDir()}
|
|
|
|
log := slog.New(slog.DiscardHandler)
|
|
d := &Daemon{
|
|
Store: st,
|
|
Trees: rootTrees,
|
|
Identities: []*IdentityRunner{
|
|
{
|
|
Name: "winter",
|
|
Trees: winterTrees,
|
|
Forge: &testForge{},
|
|
Repos: []config.Repo{{Owner: "acme", Name: "widget"}},
|
|
Cfg: config.IdentityConfig{Name: "winter"},
|
|
Log: log,
|
|
},
|
|
},
|
|
Log: log,
|
|
}
|
|
|
|
issueNum := 101
|
|
if _, err := st.EnqueueIssue(ctx, "acme", "widget", issueNum, "test task", "body", "bug", tt.taskIdentity); err != nil {
|
|
t.Fatalf("EnqueueIssue: %v", err)
|
|
}
|
|
|
|
claimed, err := st.ClaimNext(ctx)
|
|
if err != nil || claimed == nil {
|
|
t.Fatalf("ClaimNext: (%v, %v)", claimed, err)
|
|
}
|
|
|
|
if tt.setupStatus != workflow.StatusRunning {
|
|
if err := st.Transition(ctx, claimed.ID, workflow.StatusRunning, tt.setupStatus, "status update"); err != nil {
|
|
t.Fatalf("Transition to %s: %v", tt.setupStatus, err)
|
|
}
|
|
}
|
|
|
|
if tt.prNumber > 0 {
|
|
claimed.PRNumber = tt.prNumber
|
|
if err := st.Update(ctx, claimed); err != nil {
|
|
t.Fatalf("Update PRNumber: %v", err)
|
|
}
|
|
}
|
|
|
|
targetTrees := d.treesFor(claimed)
|
|
workDir := targetTrees.Dir(claimed.Owner, claimed.Repo, claimed.IssueNumber)
|
|
if err := os.MkdirAll(workDir, 0o755); err != nil {
|
|
t.Fatalf("create workDir: %v", err)
|
|
}
|
|
|
|
d.cleanupTerminalTaskWorktree(ctx, claimed, targetTrees)
|
|
|
|
_, statErr := os.Stat(workDir)
|
|
treeExists := statErr == nil
|
|
if treeExists != tt.wantTreeExists {
|
|
t.Errorf("worktree exists = %v, want %v (path: %s)", treeExists, tt.wantTreeExists, workDir)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestProcessCleansWorktreeOnTerminalNoChange(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
workerStatus string
|
|
taskIdentity string
|
|
wantTreeExists bool
|
|
}{
|
|
{
|
|
name: "process removes worktree when worker reports merged without PR",
|
|
workerStatus: workflow.StatusMerged,
|
|
taskIdentity: "",
|
|
wantTreeExists: false,
|
|
},
|
|
{
|
|
name: "process removes identity worktree when worker reports merged without PR",
|
|
workerStatus: workflow.StatusMerged,
|
|
taskIdentity: "winter",
|
|
wantTreeExists: false,
|
|
},
|
|
{
|
|
name: "process keeps worktree when worker parks task",
|
|
workerStatus: workflow.StatusParked,
|
|
taskIdentity: "",
|
|
wantTreeExists: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
host := newLocalRemote(t, "acme", "widget")
|
|
d, s, busClient := daemonWithNATS(t)
|
|
ctx := context.Background()
|
|
|
|
rootTrees := &worktree.Manager{
|
|
WorkDir: t.TempDir(),
|
|
Token: "unused",
|
|
BotUser: "archie-bot",
|
|
BotEmail: "archie-bot@example.com",
|
|
BaseURL: "file://" + host,
|
|
}
|
|
winterTrees := &worktree.Manager{
|
|
WorkDir: t.TempDir(),
|
|
Token: "unused",
|
|
BotUser: "winter-bot",
|
|
BotEmail: "winter-bot@example.com",
|
|
BaseURL: "file://" + host,
|
|
}
|
|
d.Trees = rootTrees
|
|
|
|
repo := config.Repo{Owner: "acme", Name: "widget", Base: "main"}
|
|
d.Cfg.Set(config.Config{
|
|
Repos: []config.Repo{repo},
|
|
})
|
|
|
|
d.Identities = []*IdentityRunner{
|
|
{
|
|
Name: "winter",
|
|
Trees: winterTrees,
|
|
Forge: &testForge{},
|
|
Repos: []config.Repo{repo},
|
|
Cfg: config.IdentityConfig{Name: "winter"},
|
|
Log: d.Log,
|
|
},
|
|
}
|
|
|
|
// Mock Docker API server for ContainerPool
|
|
dockerAPI := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch {
|
|
case strings.HasSuffix(r.URL.Path, "/containers/create"):
|
|
writeContainerDockerJSON(t, w, dockercontainer.CreateResponse{ID: "test-container-id"})
|
|
case strings.Contains(r.URL.Path, "/containers/test-container-id"):
|
|
w.WriteHeader(http.StatusNoContent)
|
|
case strings.HasSuffix(r.URL.Path, "/containers/json"):
|
|
writeContainerDockerJSON(t, w, []any{})
|
|
default:
|
|
http.Error(w, "unexpected Docker API path "+r.URL.Path, http.StatusNotFound)
|
|
}
|
|
}))
|
|
t.Cleanup(dockerAPI.Close)
|
|
|
|
dockerClient, err := client.New(client.WithHost(dockerAPI.URL), client.WithAPIVersion("1.55"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = dockerClient.Close() })
|
|
|
|
pool, err := archiecontainer.NewPool(ctx, archiecontainer.Config{
|
|
Image: "archie-agent:test",
|
|
DockerClient: dockerClient,
|
|
}, d.Log)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
d.ContainerPool = pool
|
|
d.Storage = &noopStorage{}
|
|
|
|
if _, err := s.EnqueueIssue(ctx, "acme", "widget", 77, "no-op issue", "body", "bug", tt.taskIdentity); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, err := s.ClaimNext(ctx)
|
|
if err != nil || task == nil {
|
|
t.Fatalf("ClaimNext: (%v, %v)", task, err)
|
|
}
|
|
|
|
targetTrees := d.treesFor(task)
|
|
workDir := targetTrees.Dir(task.Owner, task.Repo, task.IssueNumber)
|
|
|
|
sub, err := mustCoreConn(t, busClient).Subscribe(agentnats.SubjectForTask(task.ID), func(msg *natsio.Msg) {
|
|
// Transition task in store as archie-agent would do over the gRPC State Store
|
|
_ = s.Transition(ctx, task.ID, workflow.StatusRunning, tt.workerStatus, "worker completion")
|
|
resp, _ := json.Marshal(taskrun.Response{
|
|
Status: tt.workerStatus,
|
|
})
|
|
_ = msg.Respond(resp)
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = sub.Unsubscribe() })
|
|
|
|
d.process(ctx, task)
|
|
|
|
_, statErr := os.Stat(workDir)
|
|
treeExists := statErr == nil
|
|
if treeExists != tt.wantTreeExists {
|
|
t.Errorf("worktree exists = %v, want %v (path: %s)", treeExists, tt.wantTreeExists, workDir)
|
|
}
|
|
})
|
|
}
|
|
}
|