fix(state-store): task-scope container credentials, stream large capture lists, validate Update, wire dev's state-store (archie-core-8cda.4.7)

Closes six review findings against .4.6 (PR #775):

- daemon.StateStoreGrantIssuer + staterpc.TaskGrants: containers get a
  per-task credential authorized only for their own Update/Transition/
  InsertEvent, never the daemon's administrative token. Issued before
  Acquire, revoked on Release; fails closed if no issuer is wired.
- StreamCaptures/StreamUndispatchedCaptures: new streaming RPCs so a
  batch of large capture bodies can't exceed gRPC's 4MiB unary cap.
  The original unary RPCs are kept, unmodified (deprecated) rather than
  reshaped, so buf breaking stays green for an in-flight rolling deploy.
- Update rejects a nil Task with InvalidArgument instead of panicking in
  the store layer.
- RequireHostGateway only forces on for embedded NATS, so an externally
  reachable NATS/State Store no longer requires a local Docker bridge.
- Client-side token resolution now matches the server's (target_token,
  then STATE_STORE_TOKEN secret/env).
- task dev now runs archie-state-store (dev:state-store) alongside
  archied/archie-gateway/vite; deployments/dev.toml points them at it.
This commit is contained in:
sam committed 2026-09-07 13:18:44 +10:00
1 parent 33751abe4e
commit 8fef2e7eed
21 files changed
+1917 -596

No files matched your search

+18 -8
View File
@@ -89,27 +89,37 @@ tasks:
- npm test
dev:
desc: "Develop: archied live-reload + archie-gateway + Vite HMR together. Open http://localhost:5173"
desc: "Develop: archied live-reload + archie-gateway + archie-state-store + Vite HMR together. Open http://localhost:5173"
summary: |
Runs the dev loop in one terminal:
* air rebuilds and restarts archied on Go changes
* archie-gateway serves ChatContract on 127.0.0.1:8585 (archied
dials it for chat; it does not embed a gateway)
* vite serves the dashboard with hot reload on :5173,
proxying /api and /events through to archied on :8484
* air rebuilds and restarts archied on Go changes
* archie-gateway serves ChatContract on 127.0.0.1:8585 (archied
dials it for chat; it does not embed a gateway)
* archie-state-store owns archie.db on 127.0.0.1:9090, loopback,
no token (deployments/dev.toml); both archied and
archie-gateway dial it -- neither owns the DB
in-process (docs/prds/state-store-contract.md §12
step 7)
* vite serves the dashboard with hot reload on :5173,
proxying /api and /events through to archied on :8484
Open http://localhost:5173 -- not :8484. The Vite server is the one with
hot reload; :8484 serves the last built dist/ and will look stale.
Ctrl-C stops all three.
deps: [dev:daemon, dev:gateway, dev:ui]
Ctrl-C stops all four.
deps: [dev:daemon, dev:gateway, dev:state-store, dev:ui]
dev:daemon:
desc: archied only, live-reloading via air (prefer `task dev`)
cmds:
- air -build.args_bin="-config-overlay,deployments/dev.toml"
dev:state-store:
desc: archie-state-store only, no live-reload (prefer `task dev`)
cmds:
- go run ./cmd/archie-state-store -config-overlay deployments/dev.toml
dev:gateway:
desc: archie-gateway only, no live-reload (prefer `task dev`)
cmds:
+7
View File
@@ -1,3 +1,10 @@
# Match Vite's API/event proxy without changing the installed configuration.
[web]
listen = "127.0.0.1:8484"
# `task dev` also runs archie-state-store on its -listen default
# (127.0.0.1:9090, loopback, no token) via dev:state-store -- point archied
# and archie-gateway at it so a fresh dev checkout works without hand-editing
# the installed config.toml (docs/prds/state-store-contract.md §12 step 7).
[services.state]
target = "127.0.0.1:9090"
+10 -1
View File
@@ -50,6 +50,7 @@ import (
"github.com/samcharles93/archie-core/internal/infrastructure/modelcatalog"
"github.com/samcharles93/archie-core/internal/infrastructure/sessioncurator"
"github.com/samcharles93/archie-core/internal/infrastructure/skillcurator"
"github.com/samcharles93/archie-core/internal/infrastructure/staterpc"
"github.com/samcharles93/archie-core/internal/infrastructure/taskactions"
"github.com/samcharles93/archie-core/internal/logging"
"github.com/samcharles93/archie-core/internal/memory"
@@ -107,7 +108,13 @@ type boot struct {
// by openStateStoreAdapter, which requires [services.state].target to be
// set. The b.st field remains solely for the standalone archie-state-store
// binary, which owns the single SQLite file.
stateStore store.TaskStore
stateStore store.TaskStore
// stateStoreGrants issues per-task, scoped State Store credentials for
// agent containers (daemon.StateStoreGrantIssuer), wrapping the same
// *staterpc.Client as stateStore. Nil when the State Store adapter isn't
// the remote gRPC client (never true in production; state_store.go's
// standalone-only compose leaves no other case).
stateStoreGrants *staterpc.GrantIssuer
stateStoreToken string
chatSessionStore gateway.SessionStore
@@ -306,6 +313,7 @@ func (b *boot) openStateStoreAdapter() error {
return err
}
b.stateStore = client
b.stateStoreGrants = &staterpc.GrantIssuer{Client: client}
b.stateStoreToken = stateStoreResolvedToken(b.cfg.Services.State, b.secrets)
b.addCleanup(cleanup)
return nil
@@ -1269,6 +1277,7 @@ func (b *boot) buildDaemon() {
Log: log,
Tasks: b.natsClient,
WorktreeGrants: b.worktreeGrants,
StateStoreGrants: b.stateStoreGrants,
ContainerPool: b.containerPool,
Guardrails: b.guardrails,
ToolRegistry: b.toolReg,
+3 -7
View File
@@ -1065,13 +1065,9 @@ func startContainers(
PullPolicy: cfg.Containers.PullPolicy,
Network: cfg.Containers.Network,
DockerClient: dockerCli,
// Always resolve the bridge gateway: agent containers need it to
// reach embedded NATS (when configured) and the State Store gRPC
// service, whose [services.state].target must be the bridge gateway
// for a container-mode agent (docs/prds/state-store-contract.md §9's
// single listener-topology rule) -- a container can never reach the
// host's 127.0.0.1.
RequireHostGateway: true,
// Only the embedded broker binds a discovered host gateway. The
// standalone State Store uses its configured, container-reachable target.
RequireHostGateway: cfg.NATS.Mode == config.NATSModeEmbedded,
}, log)
if err != nil {
// A missing image is recoverable by hand. The daemon sends no registry
+16 -7
View File
@@ -64,9 +64,11 @@ func RunStateStore(ctx context.Context, options StateStoreOptions) error {
token := options.Token
if token == "" {
token = b.cfg.Services.State.TargetToken
token = stateStoreResolvedToken(b.cfg.Services.State, b.secrets)
}
opts, loopback, err := stateStoreServerOpts(options.Listen, token)
grants := &staterpc.TaskGrants{}
//nolint:contextcheck // grpc.StreamServerInterceptor has no context.Context parameter; TaskGrants.StreamInterceptor derives its context from stream.Context() instead
opts, loopback, err := stateStoreServerOpts(options.Listen, token, grants)
if err != nil {
return err
}
@@ -83,7 +85,7 @@ func RunStateStore(ctx context.Context, options StateStoreOptions) error {
}
}
return serveStateStore(ctx, listener, b.stateStoreDeps(), opts)
return serveStateStore(ctx, listener, b.stateStoreDeps(grants), opts)
}
// openStateStore opens the single task-store SQLite file exactly once for
@@ -122,8 +124,8 @@ func (b *boot) openStateStore(ctx context.Context) error {
// the capture/mapping/binding surfaces, so each is asserted here (the same
// pattern the daemon's wireWebStoreSurfaces uses) and a store that lacks one
// degrades that group rather than aborting boot.
func (b *boot) stateStoreDeps() staterpc.Deps {
deps := staterpc.Deps{Tasks: b.st, Log: b.log}
func (b *boot) stateStoreDeps(grants *staterpc.TaskGrants) staterpc.Deps {
deps := staterpc.Deps{Tasks: b.st, Log: b.log, Grants: grants}
if cs, ok := b.st.(store.CaptureStore); ok {
deps.Captures = cs
}
@@ -210,7 +212,7 @@ func (b *boot) startStateStoreReadiness(ctx context.Context, readyAddr string) e
// enforce TLS/mTLS (an operator decision), so it narrows the non-loopback
// path to token auth -- the same confinement philosophy as the gateway's
// loopback-only --listen rule.
func stateStoreServerOpts(listen, token string) (opts []grpc.ServerOption, loopback bool, err error) {
func stateStoreServerOpts(listen, token string, grants *staterpc.TaskGrants) (opts []grpc.ServerOption, loopback bool, err error) {
loopback, err = stateStoreListenIsLoopback(listen)
if err != nil {
return nil, false, err
@@ -224,7 +226,14 @@ func stateStoreServerOpts(listen, token string) (opts []grpc.ServerOption, loopb
listen,
)
}
return []grpc.ServerOption{grpc.ChainUnaryInterceptor(staterpc.UnaryTokenInterceptor(constantTimeTokenValidator(token)))}, false, nil
// grants.UnaryInterceptor/StreamInterceptor separate the daemon's own
// administrative token (full access) from a container's task-scoped
// grant (Update/Transition/InsertEvent on its own task ID only), rather
// than the single all-or-nothing token check this replaced.
return []grpc.ServerOption{
grpc.ChainUnaryInterceptor(grants.UnaryInterceptor(token)),
grpc.ChainStreamInterceptor(grants.StreamInterceptor(token)),
}, false, nil
}
// stateStoreListenIsLoopback reports whether listen's host is a loopback
+1 -2
View File
@@ -10,7 +10,6 @@ import (
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/infrastructure/staterpc"
"github.com/samcharles93/archie-core/internal/secret"
"github.com/samcharles93/archie-core/internal/store"
)
// composeStateStoreClient dials the State Store gRPC service the daemon's own
@@ -35,7 +34,7 @@ func stateStoreResolvedToken(settings config.ServiceConnection, secrets *secret.
return token
}
func composeStateStoreClient(settings config.ServiceConnection, secrets *secret.Registry) (store.TaskStore, func(), error) {
func composeStateStoreClient(settings config.ServiceConnection, secrets *secret.Registry) (*staterpc.Client, func(), error) {
target := strings.TrimSpace(settings.Target)
if target == "" {
return nil, nil, fmt.Errorf("services.state.target is required")
@@ -0,0 +1,58 @@
package archied
import (
"context"
"fmt"
"log/slog"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/config"
)
func TestExternalServicesDoNotRequireBridgeNetwork(t *testing.T) {
api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch {
case strings.HasSuffix(r.URL.Path, "/_ping"):
w.Header().Set("API-Version", "1.55")
_, _ = w.Write([]byte("OK"))
case strings.HasSuffix(r.URL.Path, "/containers/json"):
writeDockerResponse(t, w, []any{})
default:
http.Error(w, "bridge discovery must not be required", http.StatusBadRequest)
}
}))
defer api.Close()
t.Setenv("DOCKER_HOST", api.URL)
t.Setenv("DOCKER_API_VERSION", "1.55")
t.Setenv("DOCKER_TLS_VERIFY", "")
cfg := config.Config{}
cfg.NATS.Mode = config.NATSModeExternal
cfg.Containers.Network = "host"
cfg.Services.State.Target = "state.example.test:9090"
pool, _, cleanup := startContainers(t.Context(), cfg, slog.New(slog.DiscardHandler))
defer cleanup()
if pool == nil {
t.Fatal("external services on host networking must construct a worker pool")
}
}
func TestRunStateStoreAcceptsEnvironmentToken(t *testing.T) {
t.Setenv("STATE_STORE_TOKEN", "environment-token")
dir := t.TempDir()
path := filepath.Join(dir, "config.toml")
data := fmt.Sprintf("bot_user = 'archie'\ndb_path = %q\n[forge]\ntype = 'github'\nhost = 'https://github.example.com'\n[[repos]]\nowner = 'acme'\nname = 'widget'\n", filepath.Join(dir, "state.db"))
if err := os.WriteFile(path, []byte(data), 0o600); err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithTimeout(t.Context(), 200*time.Millisecond)
defer cancel()
if err := RunStateStore(ctx, StateStoreOptions{Config: path, Listen: "0.0.0.0:0"}); err != nil {
t.Fatalf("environment token should permit startup: %v", err)
}
}
+8 -7
View File
@@ -10,6 +10,7 @@ import (
"google.golang.org/grpc/credentials/insecure"
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
"github.com/samcharles93/archie-core/internal/infrastructure/staterpc"
"github.com/samcharles93/archie-core/internal/store"
)
@@ -49,7 +50,7 @@ func TestStateStoreListenIsLoopback(t *testing.T) {
}
func TestStateStoreServerOptsLoopbackIsInsecure(t *testing.T) {
opts, loopback, err := stateStoreServerOpts("127.0.0.1:9090", "")
opts, loopback, err := stateStoreServerOpts("127.0.0.1:9090", "", &staterpc.TaskGrants{})
if err != nil {
t.Fatalf("stateStoreServerOpts(loopback, no token) error: %v", err)
}
@@ -62,23 +63,23 @@ func TestStateStoreServerOptsLoopbackIsInsecure(t *testing.T) {
}
func TestStateStoreServerOptsNonLoopbackRequiresToken(t *testing.T) {
if _, _, err := stateStoreServerOpts("0.0.0.0:9090", ""); err == nil {
if _, _, err := stateStoreServerOpts("0.0.0.0:9090", "", &staterpc.TaskGrants{}); err == nil {
t.Fatal("non-loopback listener without a token should fail closed")
}
opts, loopback, err := stateStoreServerOpts("0.0.0.0:9090", "secret")
opts, loopback, err := stateStoreServerOpts("0.0.0.0:9090", "secret", &staterpc.TaskGrants{})
if err != nil {
t.Fatalf("non-loopback listener with a token error: %v", err)
}
if loopback {
t.Fatal("non-loopback listener should not report loopback")
}
if len(opts) != 1 {
t.Fatalf("non-loopback listener should install one server option (the token interceptor), got %d", len(opts))
if len(opts) != 2 {
t.Fatalf("non-loopback listener should install two server options (the unary and stream task-grant interceptors), got %d", len(opts))
}
}
func TestStateStoreServerOptsMalformedListen(t *testing.T) {
if _, _, err := stateStoreServerOpts("not-an-address", ""); err == nil {
if _, _, err := stateStoreServerOpts("not-an-address", "", &staterpc.TaskGrants{}); err == nil {
t.Fatal("malformed listen address should error")
}
}
@@ -120,7 +121,7 @@ func TestServeStateStoreServesContract(t *testing.T) {
defer listener.Close()
serveCh := make(chan error, 1)
go func() { serveCh <- serveStateStore(ctx, listener, b.stateStoreDeps(), nil) }()
go func() { serveCh <- serveStateStore(ctx, listener, b.stateStoreDeps(&staterpc.TaskGrants{}), nil) }()
conn, err := grpc.NewClient("passthrough:///"+listener.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
File diff suppressed because it is too large. Load diff
+226 -41
View File
@@ -19,46 +19,50 @@ import (
const _ = grpc.SupportPackageIsVersion9
const (
StateStoreService_EnqueueIssue_FullMethodName = "/state.v1.StateStoreService/EnqueueIssue"
StateStoreService_EnqueueChatTask_FullMethodName = "/state.v1.StateStoreService/EnqueueChatTask"
StateStoreService_ClaimNext_FullMethodName = "/state.v1.StateStoreService/ClaimNext"
StateStoreService_ClaimByIssue_FullMethodName = "/state.v1.StateStoreService/ClaimByIssue"
StateStoreService_Transition_FullMethodName = "/state.v1.StateStoreService/Transition"
StateStoreService_Update_FullMethodName = "/state.v1.StateStoreService/Update"
StateStoreService_Requeue_FullMethodName = "/state.v1.StateStoreService/Requeue"
StateStoreService_RecoverStale_FullMethodName = "/state.v1.StateStoreService/RecoverStale"
StateStoreService_ArchiveTask_FullMethodName = "/state.v1.StateStoreService/ArchiveTask"
StateStoreService_RetryTask_FullMethodName = "/state.v1.StateStoreService/RetryTask"
StateStoreService_TaskByIssue_FullMethodName = "/state.v1.StateStoreService/TaskByIssue"
StateStoreService_TaskByID_FullMethodName = "/state.v1.StateStoreService/TaskByID"
StateStoreService_OpenPRs_FullMethodName = "/state.v1.StateStoreService/OpenPRs"
StateStoreService_ClearTerminalTasks_FullMethodName = "/state.v1.StateStoreService/ClearTerminalTasks"
StateStoreService_Tasks_FullMethodName = "/state.v1.StateStoreService/Tasks"
StateStoreService_StatusCounts_FullMethodName = "/state.v1.StateStoreService/StatusCounts"
StateStoreService_IncrementRetryCount_FullMethodName = "/state.v1.StateStoreService/IncrementRetryCount"
StateStoreService_InsertEvent_FullMethodName = "/state.v1.StateStoreService/InsertEvent"
StateStoreService_EventsSince_FullMethodName = "/state.v1.StateStoreService/EventsSince"
StateStoreService_TaskEvents_FullMethodName = "/state.v1.StateStoreService/TaskEvents"
StateStoreService_WorkflowStats_FullMethodName = "/state.v1.StateStoreService/WorkflowStats"
StateStoreService_StageStats_FullMethodName = "/state.v1.StateStoreService/StageStats"
StateStoreService_TokensByDay_FullMethodName = "/state.v1.StateStoreService/TokensByDay"
StateStoreService_InsertCapture_FullMethodName = "/state.v1.StateStoreService/InsertCapture"
StateStoreService_ListCaptures_FullMethodName = "/state.v1.StateStoreService/ListCaptures"
StateStoreService_InsertMapping_FullMethodName = "/state.v1.StateStoreService/InsertMapping"
StateStoreService_GetMapping_FullMethodName = "/state.v1.StateStoreService/GetMapping"
StateStoreService_ListMappings_FullMethodName = "/state.v1.StateStoreService/ListMappings"
StateStoreService_UpdateMapping_FullMethodName = "/state.v1.StateStoreService/UpdateMapping"
StateStoreService_DeleteMapping_FullMethodName = "/state.v1.StateStoreService/DeleteMapping"
StateStoreService_InsertBinding_FullMethodName = "/state.v1.StateStoreService/InsertBinding"
StateStoreService_GetBinding_FullMethodName = "/state.v1.StateStoreService/GetBinding"
StateStoreService_ListBindings_FullMethodName = "/state.v1.StateStoreService/ListBindings"
StateStoreService_UpdateBinding_FullMethodName = "/state.v1.StateStoreService/UpdateBinding"
StateStoreService_DeleteBinding_FullMethodName = "/state.v1.StateStoreService/DeleteBinding"
StateStoreService_ApproveBinding_FullMethodName = "/state.v1.StateStoreService/ApproveBinding"
StateStoreService_ArmedBindingsForSource_FullMethodName = "/state.v1.StateStoreService/ArmedBindingsForSource"
StateStoreService_RecordDispatch_FullMethodName = "/state.v1.StateStoreService/RecordDispatch"
StateStoreService_ListUndispatchedCaptures_FullMethodName = "/state.v1.StateStoreService/ListUndispatchedCaptures"
StateStoreService_EnqueueBindingTask_FullMethodName = "/state.v1.StateStoreService/EnqueueBindingTask"
StateStoreService_RegisterTaskGrant_FullMethodName = "/state.v1.StateStoreService/RegisterTaskGrant"
StateStoreService_RevokeTaskGrant_FullMethodName = "/state.v1.StateStoreService/RevokeTaskGrant"
StateStoreService_EnqueueIssue_FullMethodName = "/state.v1.StateStoreService/EnqueueIssue"
StateStoreService_EnqueueChatTask_FullMethodName = "/state.v1.StateStoreService/EnqueueChatTask"
StateStoreService_ClaimNext_FullMethodName = "/state.v1.StateStoreService/ClaimNext"
StateStoreService_ClaimByIssue_FullMethodName = "/state.v1.StateStoreService/ClaimByIssue"
StateStoreService_Transition_FullMethodName = "/state.v1.StateStoreService/Transition"
StateStoreService_Update_FullMethodName = "/state.v1.StateStoreService/Update"
StateStoreService_Requeue_FullMethodName = "/state.v1.StateStoreService/Requeue"
StateStoreService_RecoverStale_FullMethodName = "/state.v1.StateStoreService/RecoverStale"
StateStoreService_ArchiveTask_FullMethodName = "/state.v1.StateStoreService/ArchiveTask"
StateStoreService_RetryTask_FullMethodName = "/state.v1.StateStoreService/RetryTask"
StateStoreService_TaskByIssue_FullMethodName = "/state.v1.StateStoreService/TaskByIssue"
StateStoreService_TaskByID_FullMethodName = "/state.v1.StateStoreService/TaskByID"
StateStoreService_OpenPRs_FullMethodName = "/state.v1.StateStoreService/OpenPRs"
StateStoreService_ClearTerminalTasks_FullMethodName = "/state.v1.StateStoreService/ClearTerminalTasks"
StateStoreService_Tasks_FullMethodName = "/state.v1.StateStoreService/Tasks"
StateStoreService_StatusCounts_FullMethodName = "/state.v1.StateStoreService/StatusCounts"
StateStoreService_IncrementRetryCount_FullMethodName = "/state.v1.StateStoreService/IncrementRetryCount"
StateStoreService_InsertEvent_FullMethodName = "/state.v1.StateStoreService/InsertEvent"
StateStoreService_EventsSince_FullMethodName = "/state.v1.StateStoreService/EventsSince"
StateStoreService_TaskEvents_FullMethodName = "/state.v1.StateStoreService/TaskEvents"
StateStoreService_WorkflowStats_FullMethodName = "/state.v1.StateStoreService/WorkflowStats"
StateStoreService_StageStats_FullMethodName = "/state.v1.StateStoreService/StageStats"
StateStoreService_TokensByDay_FullMethodName = "/state.v1.StateStoreService/TokensByDay"
StateStoreService_InsertCapture_FullMethodName = "/state.v1.StateStoreService/InsertCapture"
StateStoreService_ListCaptures_FullMethodName = "/state.v1.StateStoreService/ListCaptures"
StateStoreService_StreamCaptures_FullMethodName = "/state.v1.StateStoreService/StreamCaptures"
StateStoreService_InsertMapping_FullMethodName = "/state.v1.StateStoreService/InsertMapping"
StateStoreService_GetMapping_FullMethodName = "/state.v1.StateStoreService/GetMapping"
StateStoreService_ListMappings_FullMethodName = "/state.v1.StateStoreService/ListMappings"
StateStoreService_UpdateMapping_FullMethodName = "/state.v1.StateStoreService/UpdateMapping"
StateStoreService_DeleteMapping_FullMethodName = "/state.v1.StateStoreService/DeleteMapping"
StateStoreService_InsertBinding_FullMethodName = "/state.v1.StateStoreService/InsertBinding"
StateStoreService_GetBinding_FullMethodName = "/state.v1.StateStoreService/GetBinding"
StateStoreService_ListBindings_FullMethodName = "/state.v1.StateStoreService/ListBindings"
StateStoreService_UpdateBinding_FullMethodName = "/state.v1.StateStoreService/UpdateBinding"
StateStoreService_DeleteBinding_FullMethodName = "/state.v1.StateStoreService/DeleteBinding"
StateStoreService_ApproveBinding_FullMethodName = "/state.v1.StateStoreService/ApproveBinding"
StateStoreService_ArmedBindingsForSource_FullMethodName = "/state.v1.StateStoreService/ArmedBindingsForSource"
StateStoreService_RecordDispatch_FullMethodName = "/state.v1.StateStoreService/RecordDispatch"
StateStoreService_ListUndispatchedCaptures_FullMethodName = "/state.v1.StateStoreService/ListUndispatchedCaptures"
StateStoreService_StreamUndispatchedCaptures_FullMethodName = "/state.v1.StateStoreService/StreamUndispatchedCaptures"
StateStoreService_EnqueueBindingTask_FullMethodName = "/state.v1.StateStoreService/EnqueueBindingTask"
)
// StateStoreServiceClient is the client API for StateStoreService service.
@@ -73,6 +77,9 @@ const (
// the same *store.Store implementation; the proto bypasses the Go
// interfacebloat cap (max 8), like gateway.v1.ChatService does.
type StateStoreServiceClient interface {
// Administrative task credential lifecycle. Worker credentials cannot call these.
RegisterTaskGrant(ctx context.Context, in *RegisterTaskGrantRequest, opts ...grpc.CallOption) (*RegisterTaskGrantResponse, error)
RevokeTaskGrant(ctx context.Context, in *RevokeTaskGrantRequest, opts ...grpc.CallOption) (*RevokeTaskGrantResponse, error)
// Lifecycle
EnqueueIssue(ctx context.Context, in *EnqueueIssueRequest, opts ...grpc.CallOption) (*EnqueueIssueResponse, error)
EnqueueChatTask(ctx context.Context, in *EnqueueChatTaskRequest, opts ...grpc.CallOption) (*EnqueueChatTaskResponse, error)
@@ -102,7 +109,16 @@ type StateStoreServiceClient interface {
TokensByDay(ctx context.Context, in *TokensByDayRequest, opts ...grpc.CallOption) (*TokensByDayResponse, error)
// Capture
InsertCapture(ctx context.Context, in *InsertCaptureRequest, opts ...grpc.CallOption) (*InsertCaptureResponse, error)
// Deprecated: Do not use.
// ListCaptures is superseded by StreamCaptures (kept, unmodified, so an
// in-flight rolling deploy's old client/server pairing keeps working --
// buf breaking forbids removing or reshaping an existing RPC). Every
// in-repo caller uses StreamCaptures.
ListCaptures(ctx context.Context, in *ListCapturesRequest, opts ...grpc.CallOption) (*ListCapturesResponse, error)
// StreamCaptures returns one capture per message: a batch of large capture
// bodies can exceed gRPC's 4MiB unary message cap
// (docs/prds/state-store-contract.md).
StreamCaptures(ctx context.Context, in *StreamCapturesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StreamCapturesResponse], error)
// Mapping
InsertMapping(ctx context.Context, in *InsertMappingRequest, opts ...grpc.CallOption) (*InsertMappingResponse, error)
GetMapping(ctx context.Context, in *GetMappingRequest, opts ...grpc.CallOption) (*GetMappingResponse, error)
@@ -119,7 +135,11 @@ type StateStoreServiceClient interface {
// Dispatch
ArmedBindingsForSource(ctx context.Context, in *ArmedBindingsForSourceRequest, opts ...grpc.CallOption) (*ArmedBindingsForSourceResponse, error)
RecordDispatch(ctx context.Context, in *RecordDispatchRequest, opts ...grpc.CallOption) (*RecordDispatchResponse, error)
// Deprecated: Do not use.
// ListUndispatchedCaptures is superseded by StreamUndispatchedCaptures; see
// ListCaptures above.
ListUndispatchedCaptures(ctx context.Context, in *ListUndispatchedCapturesRequest, opts ...grpc.CallOption) (*ListUndispatchedCapturesResponse, error)
StreamUndispatchedCaptures(ctx context.Context, in *StreamUndispatchedCapturesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StreamUndispatchedCapturesResponse], error)
// BindingTaskCreator
EnqueueBindingTask(ctx context.Context, in *EnqueueBindingTaskRequest, opts ...grpc.CallOption) (*EnqueueBindingTaskResponse, error)
}
@@ -132,6 +152,26 @@ func NewStateStoreServiceClient(cc grpc.ClientConnInterface) StateStoreServiceCl
return &stateStoreServiceClient{cc}
}
func (c *stateStoreServiceClient) RegisterTaskGrant(ctx context.Context, in *RegisterTaskGrantRequest, opts ...grpc.CallOption) (*RegisterTaskGrantResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(RegisterTaskGrantResponse)
err := c.cc.Invoke(ctx, StateStoreService_RegisterTaskGrant_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreServiceClient) RevokeTaskGrant(ctx context.Context, in *RevokeTaskGrantRequest, opts ...grpc.CallOption) (*RevokeTaskGrantResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(RevokeTaskGrantResponse)
err := c.cc.Invoke(ctx, StateStoreService_RevokeTaskGrant_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreServiceClient) EnqueueIssue(ctx context.Context, in *EnqueueIssueRequest, opts ...grpc.CallOption) (*EnqueueIssueResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(EnqueueIssueResponse)
@@ -372,6 +412,7 @@ func (c *stateStoreServiceClient) InsertCapture(ctx context.Context, in *InsertC
return out, nil
}
// Deprecated: Do not use.
func (c *stateStoreServiceClient) ListCaptures(ctx context.Context, in *ListCapturesRequest, opts ...grpc.CallOption) (*ListCapturesResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(ListCapturesResponse)
@@ -382,6 +423,25 @@ func (c *stateStoreServiceClient) ListCaptures(ctx context.Context, in *ListCapt
return out, nil
}
func (c *stateStoreServiceClient) StreamCaptures(ctx context.Context, in *StreamCapturesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StreamCapturesResponse], error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
stream, err := c.cc.NewStream(ctx, &StateStoreService_ServiceDesc.Streams[0], StateStoreService_StreamCaptures_FullMethodName, cOpts...)
if err != nil {
return nil, err
}
x := &grpc.GenericClientStream[StreamCapturesRequest, StreamCapturesResponse]{ClientStream: stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type StateStoreService_StreamCapturesClient = grpc.ServerStreamingClient[StreamCapturesResponse]
func (c *stateStoreServiceClient) InsertMapping(ctx context.Context, in *InsertMappingRequest, opts ...grpc.CallOption) (*InsertMappingResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(InsertMappingResponse)
@@ -512,6 +572,7 @@ func (c *stateStoreServiceClient) RecordDispatch(ctx context.Context, in *Record
return out, nil
}
// Deprecated: Do not use.
func (c *stateStoreServiceClient) ListUndispatchedCaptures(ctx context.Context, in *ListUndispatchedCapturesRequest, opts ...grpc.CallOption) (*ListUndispatchedCapturesResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(ListUndispatchedCapturesResponse)
@@ -522,6 +583,25 @@ func (c *stateStoreServiceClient) ListUndispatchedCaptures(ctx context.Context,
return out, nil
}
func (c *stateStoreServiceClient) StreamUndispatchedCaptures(ctx context.Context, in *StreamUndispatchedCapturesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StreamUndispatchedCapturesResponse], error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
stream, err := c.cc.NewStream(ctx, &StateStoreService_ServiceDesc.Streams[1], StateStoreService_StreamUndispatchedCaptures_FullMethodName, cOpts...)
if err != nil {
return nil, err
}
x := &grpc.GenericClientStream[StreamUndispatchedCapturesRequest, StreamUndispatchedCapturesResponse]{ClientStream: stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type StateStoreService_StreamUndispatchedCapturesClient = grpc.ServerStreamingClient[StreamUndispatchedCapturesResponse]
func (c *stateStoreServiceClient) EnqueueBindingTask(ctx context.Context, in *EnqueueBindingTaskRequest, opts ...grpc.CallOption) (*EnqueueBindingTaskResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(EnqueueBindingTaskResponse)
@@ -544,6 +624,9 @@ func (c *stateStoreServiceClient) EnqueueBindingTask(ctx context.Context, in *En
// the same *store.Store implementation; the proto bypasses the Go
// interfacebloat cap (max 8), like gateway.v1.ChatService does.
type StateStoreServiceServer interface {
// Administrative task credential lifecycle. Worker credentials cannot call these.
RegisterTaskGrant(context.Context, *RegisterTaskGrantRequest) (*RegisterTaskGrantResponse, error)
RevokeTaskGrant(context.Context, *RevokeTaskGrantRequest) (*RevokeTaskGrantResponse, error)
// Lifecycle
EnqueueIssue(context.Context, *EnqueueIssueRequest) (*EnqueueIssueResponse, error)
EnqueueChatTask(context.Context, *EnqueueChatTaskRequest) (*EnqueueChatTaskResponse, error)
@@ -573,7 +656,16 @@ type StateStoreServiceServer interface {
TokensByDay(context.Context, *TokensByDayRequest) (*TokensByDayResponse, error)
// Capture
InsertCapture(context.Context, *InsertCaptureRequest) (*InsertCaptureResponse, error)
// Deprecated: Do not use.
// ListCaptures is superseded by StreamCaptures (kept, unmodified, so an
// in-flight rolling deploy's old client/server pairing keeps working --
// buf breaking forbids removing or reshaping an existing RPC). Every
// in-repo caller uses StreamCaptures.
ListCaptures(context.Context, *ListCapturesRequest) (*ListCapturesResponse, error)
// StreamCaptures returns one capture per message: a batch of large capture
// bodies can exceed gRPC's 4MiB unary message cap
// (docs/prds/state-store-contract.md).
StreamCaptures(*StreamCapturesRequest, grpc.ServerStreamingServer[StreamCapturesResponse]) error
// Mapping
InsertMapping(context.Context, *InsertMappingRequest) (*InsertMappingResponse, error)
GetMapping(context.Context, *GetMappingRequest) (*GetMappingResponse, error)
@@ -590,7 +682,11 @@ type StateStoreServiceServer interface {
// Dispatch
ArmedBindingsForSource(context.Context, *ArmedBindingsForSourceRequest) (*ArmedBindingsForSourceResponse, error)
RecordDispatch(context.Context, *RecordDispatchRequest) (*RecordDispatchResponse, error)
// Deprecated: Do not use.
// ListUndispatchedCaptures is superseded by StreamUndispatchedCaptures; see
// ListCaptures above.
ListUndispatchedCaptures(context.Context, *ListUndispatchedCapturesRequest) (*ListUndispatchedCapturesResponse, error)
StreamUndispatchedCaptures(*StreamUndispatchedCapturesRequest, grpc.ServerStreamingServer[StreamUndispatchedCapturesResponse]) error
// BindingTaskCreator
EnqueueBindingTask(context.Context, *EnqueueBindingTaskRequest) (*EnqueueBindingTaskResponse, error)
mustEmbedUnimplementedStateStoreServiceServer()
@@ -603,6 +699,12 @@ type StateStoreServiceServer interface {
// pointer dereference when methods are called.
type UnimplementedStateStoreServiceServer struct{}
func (UnimplementedStateStoreServiceServer) RegisterTaskGrant(context.Context, *RegisterTaskGrantRequest) (*RegisterTaskGrantResponse, error) {
return nil, status.Error(codes.Unimplemented, "method RegisterTaskGrant not implemented")
}
func (UnimplementedStateStoreServiceServer) RevokeTaskGrant(context.Context, *RevokeTaskGrantRequest) (*RevokeTaskGrantResponse, error) {
return nil, status.Error(codes.Unimplemented, "method RevokeTaskGrant not implemented")
}
func (UnimplementedStateStoreServiceServer) EnqueueIssue(context.Context, *EnqueueIssueRequest) (*EnqueueIssueResponse, error) {
return nil, status.Error(codes.Unimplemented, "method EnqueueIssue not implemented")
}
@@ -678,6 +780,9 @@ func (UnimplementedStateStoreServiceServer) InsertCapture(context.Context, *Inse
func (UnimplementedStateStoreServiceServer) ListCaptures(context.Context, *ListCapturesRequest) (*ListCapturesResponse, error) {
return nil, status.Error(codes.Unimplemented, "method ListCaptures not implemented")
}
func (UnimplementedStateStoreServiceServer) StreamCaptures(*StreamCapturesRequest, grpc.ServerStreamingServer[StreamCapturesResponse]) error {
return status.Error(codes.Unimplemented, "method StreamCaptures not implemented")
}
func (UnimplementedStateStoreServiceServer) InsertMapping(context.Context, *InsertMappingRequest) (*InsertMappingResponse, error) {
return nil, status.Error(codes.Unimplemented, "method InsertMapping not implemented")
}
@@ -720,6 +825,9 @@ func (UnimplementedStateStoreServiceServer) RecordDispatch(context.Context, *Rec
func (UnimplementedStateStoreServiceServer) ListUndispatchedCaptures(context.Context, *ListUndispatchedCapturesRequest) (*ListUndispatchedCapturesResponse, error) {
return nil, status.Error(codes.Unimplemented, "method ListUndispatchedCaptures not implemented")
}
func (UnimplementedStateStoreServiceServer) StreamUndispatchedCaptures(*StreamUndispatchedCapturesRequest, grpc.ServerStreamingServer[StreamUndispatchedCapturesResponse]) error {
return status.Error(codes.Unimplemented, "method StreamUndispatchedCaptures not implemented")
}
func (UnimplementedStateStoreServiceServer) EnqueueBindingTask(context.Context, *EnqueueBindingTaskRequest) (*EnqueueBindingTaskResponse, error) {
return nil, status.Error(codes.Unimplemented, "method EnqueueBindingTask not implemented")
}
@@ -744,6 +852,42 @@ func RegisterStateStoreServiceServer(s grpc.ServiceRegistrar, srv StateStoreServ
s.RegisterService(&StateStoreService_ServiceDesc, srv)
}
func _StateStoreService_RegisterTaskGrant_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RegisterTaskGrantRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).RegisterTaskGrant(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_RegisterTaskGrant_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).RegisterTaskGrant(ctx, req.(*RegisterTaskGrantRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_RevokeTaskGrant_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RevokeTaskGrantRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).RevokeTaskGrant(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_RevokeTaskGrant_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).RevokeTaskGrant(ctx, req.(*RevokeTaskGrantRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_EnqueueIssue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(EnqueueIssueRequest)
if err := dec(in); err != nil {
@@ -1194,6 +1338,17 @@ func _StateStoreService_ListCaptures_Handler(srv interface{}, ctx context.Contex
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_StreamCaptures_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(StreamCapturesRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(StateStoreServiceServer).StreamCaptures(m, &grpc.GenericServerStream[StreamCapturesRequest, StreamCapturesResponse]{ServerStream: stream})
}
// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type StateStoreService_StreamCapturesServer = grpc.ServerStreamingServer[StreamCapturesResponse]
func _StateStoreService_InsertMapping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(InsertMappingRequest)
if err := dec(in); err != nil {
@@ -1446,6 +1601,17 @@ func _StateStoreService_ListUndispatchedCaptures_Handler(srv interface{}, ctx co
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_StreamUndispatchedCaptures_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(StreamUndispatchedCapturesRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(StateStoreServiceServer).StreamUndispatchedCaptures(m, &grpc.GenericServerStream[StreamUndispatchedCapturesRequest, StreamUndispatchedCapturesResponse]{ServerStream: stream})
}
// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type StateStoreService_StreamUndispatchedCapturesServer = grpc.ServerStreamingServer[StreamUndispatchedCapturesResponse]
func _StateStoreService_EnqueueBindingTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(EnqueueBindingTaskRequest)
if err := dec(in); err != nil {
@@ -1471,6 +1637,14 @@ var StateStoreService_ServiceDesc = grpc.ServiceDesc{
ServiceName: "state.v1.StateStoreService",
HandlerType: (*StateStoreServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "RegisterTaskGrant",
Handler: _StateStoreService_RegisterTaskGrant_Handler,
},
{
MethodName: "RevokeTaskGrant",
Handler: _StateStoreService_RevokeTaskGrant_Handler,
},
{
MethodName: "EnqueueIssue",
Handler: _StateStoreService_EnqueueIssue_Handler,
@@ -1632,6 +1806,17 @@ var StateStoreService_ServiceDesc = grpc.ServiceDesc{
Handler: _StateStoreService_EnqueueBindingTask_Handler,
},
},
Streams: []grpc.StreamDesc{},
Streams: []grpc.StreamDesc{
{
StreamName: "StreamCaptures",
Handler: _StateStoreService_StreamCaptures_Handler,
ServerStreams: true,
},
{
StreamName: "StreamUndispatchedCaptures",
Handler: _StateStoreService_StreamUndispatchedCaptures_Handler,
ServerStreams: true,
},
},
Metadata: "state/v1/state.proto",
}
+1 -1
View File
@@ -81,7 +81,7 @@ func TestConnectedNATSEndpointReachesManagedContainerCreate(t *testing.T) {
Token: token,
},
}
if _, err := pool.Acquire(t.Context(), nil, d.containerEnv(nil)); err != nil {
if _, err := pool.Acquire(t.Context(), nil, d.containerEnv(nil, "")); err != nil {
t.Fatalf("Pool.Acquire = %v", err)
}
+61 -13
View File
@@ -54,6 +54,15 @@ type WorktreeGrantIssuer interface {
Issue(task *workflow.Task) (token string, revoke func(), err error)
}
// StateStoreGrantIssuer gives one container dispatch a State Store credential
// scoped to that task's own workflow.Store RPCs (Update, Transition,
// InsertEvent) -- never the daemon's own administrative credential. The
// daemon owns grant lifetime (issue before Acquire, revoke on Release); the
// transport implementation (staterpc.GrantIssuer) owns token mechanics.
type StateStoreGrantIssuer interface {
Issue(task *workflow.Task) (token string, revoke func(), err error)
}
// NATSEndpoint is the broker address and credential archied connected with at
// startup. It is runtime state rather than configuration: embedded mode
// generates both values, and external secret references are resolved once.
@@ -119,6 +128,11 @@ type Daemon struct {
// bus is configured; the existing SQLite ClaimNext flow is used.
Tasks TaskBus
WorktreeGrants WorktreeGrantIssuer
// StateStoreGrants issues per-task State Store credentials for container
// env (see containerEnv). Required whenever ConnectedStateStore.URL is
// set -- acquireTaskContainer parks the task rather than fall back to
// forwarding the daemon's own administrative token.
StateStoreGrants StateStoreGrantIssuer
// TaskRunReadyTimeout bounds how long runViaAgent retries an initial
// taskrun request that fails with nats.ErrNoResponders, giving a
// freshly spawned archie-agent container time to connect to NATS, set
@@ -1101,11 +1115,12 @@ func (d *Daemon) process(ctx context.Context, task *workflow.Task) {
d.Log.Warn("task branch not persisted", "task", task.ID, "err", err)
}
ctr, ok := d.acquireTaskContainer(ctx, task, repo, workDir)
ctr, revokeStateStoreGrant, ok := d.acquireTaskContainer(ctx, task, repo, workDir)
if !ok {
return
}
defer d.ContainerPool.Release(ctx, ctr)
defer revokeStateStoreGrant()
// Hand the whole task to archie-agent in one NATS round trip. archie-agent
// proxies Store/Forge/worktree-push calls back to archied over storerpc/
@@ -1183,7 +1198,7 @@ func (d *Daemon) acquireTaskContainer(
task *workflow.Task,
repo config.Repo,
workDir string,
) (*container.Container, bool) {
) (*container.Container, func(), bool) {
park := func(reason string, err error) {
d.Log.Error(reason, "err", err)
d.parkRunningTask(ctx, task.ID, reason+": "+err.Error())
@@ -1197,7 +1212,7 @@ func (d *Daemon) acquireTaskContainer(
Workflow: task.Workflow, Branch: task.Branch, Plan: task.Plan,
}); err != nil {
park("task.json write failed", err)
return nil, false
return nil, nil, false
}
// Guard: Storage may be nil if the daemon was wired incorrectly. In
@@ -1205,7 +1220,7 @@ func (d *Daemon) acquireTaskContainer(
if d.Storage == nil {
d.Log.Error("storage backend is nil -- cannot acquire container")
d.parkRunningTask(ctx, task.ID, "storage backend not configured")
return nil, false
return nil, nil, false
}
mounts, err := d.Storage.Setup(ctx, storage.TaskRef{
@@ -1217,11 +1232,27 @@ func (d *Daemon) acquireTaskContainer(
})
if err != nil {
park("storage setup failed", err)
return nil, false
return nil, nil, false
}
ctr, err := d.ContainerPool.Acquire(ctx, mounts, d.containerEnv(task))
stateStoreToken, revokeStateStoreGrant, err := d.stateStoreGrantToken(task)
if err != nil {
if terr := d.Storage.Teardown(ctx, storage.TaskRef{
WorktreeDir: workDir,
Ecosystem: repo.Ecosystem,
PersistentStorage: repo.PersistentStorage,
Owner: task.Owner,
Repo: task.Repo,
}); terr != nil {
d.Log.Warn("storage teardown after state store grant failure failed", "err", terr)
}
park("state store grant failed", err)
return nil, nil, false
}
ctr, err := d.ContainerPool.Acquire(ctx, mounts, d.containerEnv(task, stateStoreToken))
if err != nil {
revokeStateStoreGrant()
// Roll back the storage we just set up: the mounts were created
// for this task but no container will use them. Leaking them until
// a later TTL sweep is not acceptable on a backend that allocates
@@ -1236,9 +1267,9 @@ func (d *Daemon) acquireTaskContainer(
d.Log.Warn("storage teardown after acquire failure failed", "err", terr)
}
park("container acquire failed", err)
return nil, false
return nil, nil, false
}
return ctr, true
return ctr, revokeStateStoreGrant, true
}
// parkRunningTask transitions a task from running to parked using a context
@@ -1394,7 +1425,7 @@ func (d *Daemon) requestTaskRun(ctx context.Context, taskID int64, data []byte)
}
}
func (d *Daemon) containerEnv(task *workflow.Task) []string {
func (d *Daemon) containerEnv(task *workflow.Task, stateStoreToken string) []string {
var env []string
// The endpoint the daemon's own client connected with at startup, not
// the live config: a reloaded [nats] section must not point new
@@ -1406,12 +1437,14 @@ func (d *Daemon) containerEnv(task *workflow.Task) []string {
// The State Store gRPC target follows the same seam as NATS_URL/
// NATS_TOKEN above (docs/prds/state-store-contract.md §6). It is always
// the configured [services.state].target after the in-process serving
// path is deleted; the token is the same one the daemon client presents,
// so archie-agent authenticates to the same archie-state-store service.
// path is deleted. stateStoreToken is this task's own scoped credential
// (see stateStoreGrantToken) -- never d.ConnectedStateStore.Token, which
// is the daemon's administrative credential and must never reach a
// container.
if d.ConnectedStateStore.URL != "" {
env = append(env, "STATE_STORE_URL="+d.ConnectedStateStore.URL)
if d.ConnectedStateStore.Token != "" {
env = append(env, "STATE_STORE_TOKEN="+d.ConnectedStateStore.Token)
if stateStoreToken != "" {
env = append(env, "STATE_STORE_TOKEN="+stateStoreToken)
}
}
// The agent process runs as root inside the container (no USER in the
@@ -1433,6 +1466,21 @@ func (d *Daemon) containerEnv(task *workflow.Task) []string {
return env
}
// stateStoreGrantToken issues this task's scoped State Store credential, or
// ("", no-op revoke, nil) when no State Store is configured. It fails closed
// -- rather than falling back to the daemon's administrative token -- when a
// State Store is configured but no StateStoreGrantIssuer is wired, which is
// a composition bug, not a runtime condition to paper over.
func (d *Daemon) stateStoreGrantToken(task *workflow.Task) (string, func(), error) {
if d.ConnectedStateStore.URL == "" {
return "", func() {}, nil
}
if d.StateStoreGrants == nil {
return "", nil, fmt.Errorf("state store is configured but no task-scoped grant issuer is wired")
}
return d.StateStoreGrants.Issue(task)
}
func (d *Daemon) configFor(task *workflow.Task) config.Config {
if id := d.identityFor(task); id != nil {
return configForIdentity(d.Cfg.Get(), id.Cfg)
+3 -3
View File
@@ -398,7 +398,7 @@ func TestContainerEnvIncludesConfiguredNATSCredentials(t *testing.T) {
// with a credential the broker never adopted.
t.Setenv("ARCHIE_NATS_SECRET", "changed-after-startup")
got := d.containerEnv(nil)
got := d.containerEnv(nil, "")
for _, want := range []string{
"NATS_URL=nats://nats.example:4222",
"NATS_TOKEN=test-nats-token",
@@ -422,7 +422,7 @@ func TestContainerEnvIncludesWorktreeOwnership(t *testing.T) {
Cfg: config.NewHolder(config.Config{}),
}
got := d.containerEnv(nil)
got := d.containerEnv(nil, "")
for _, want := range []string{
fmt.Sprintf("WORKTREE_UID=%d", os.Getuid()),
fmt.Sprintf("WORKTREE_GID=%d", os.Getgid()),
@@ -448,7 +448,7 @@ func TestContainerEnvUsesOnlyOwningIdentityProviderCredential(t *testing.T) {
}},
}
got := d.containerEnv(&workflow.Task{Identity: "worker"})
got := d.containerEnv(&workflow.Task{Identity: "worker"}, "")
if !slices.Contains(got, "WORKER_PROVIDER_KEY=worker-secret") {
t.Fatalf("identity credential missing from container env: %q", got)
}
@@ -0,0 +1,77 @@
package daemon
import (
"slices"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/workflow"
)
// fakeStateStoreGrants issues a fixed, task-scoped token and records revoke
// calls, standing in for staterpc.GrantIssuer in daemon-level tests.
type fakeStateStoreGrants struct {
token string
err error
revoked int
}
func (f *fakeStateStoreGrants) Issue(*workflow.Task) (string, func(), error) {
if f.err != nil {
return "", nil, f.err
}
return f.token, func() { f.revoked++ }, nil
}
func TestContainerEnvNeverExposesStateStoreAdminToken(t *testing.T) {
d := &Daemon{Cfg: config.NewHolder(config.Config{}), ConnectedStateStore: StateStoreEndpoint{URL: "127.0.0.1:9090", Token: "admin-secret"}}
for _, entry := range d.containerEnv(&workflow.Task{ID: 42}, "task-scoped-token") {
if strings.Contains(entry, "admin-secret") {
t.Fatalf("container receives administrative credential: %s", entry)
}
}
}
func TestContainerEnvCarriesTaskScopedStateStoreToken(t *testing.T) {
d := &Daemon{Cfg: config.NewHolder(config.Config{}), ConnectedStateStore: StateStoreEndpoint{URL: "127.0.0.1:9090", Token: "admin-secret"}}
got := d.containerEnv(&workflow.Task{ID: 42}, "task-scoped-token")
if !slices.Contains(got, "STATE_STORE_TOKEN=task-scoped-token") {
t.Fatalf("containerEnv() = %q, want STATE_STORE_TOKEN=task-scoped-token", got)
}
}
func TestStateStoreGrantTokenIssuesFromWiredGrants(t *testing.T) {
grants := &fakeStateStoreGrants{token: "task-scoped-token"}
d := &Daemon{ConnectedStateStore: StateStoreEndpoint{URL: "127.0.0.1:9090"}, StateStoreGrants: grants}
token, revoke, err := d.stateStoreGrantToken(&workflow.Task{ID: 42})
if err != nil {
t.Fatalf("stateStoreGrantToken: %v", err)
}
if token != "task-scoped-token" {
t.Fatalf("token = %q, want %q", token, "task-scoped-token")
}
revoke()
if grants.revoked != 1 {
t.Fatalf("revoked = %d, want 1", grants.revoked)
}
}
func TestStateStoreGrantTokenFailsClosedWithoutIssuer(t *testing.T) {
d := &Daemon{ConnectedStateStore: StateStoreEndpoint{URL: "127.0.0.1:9090"}}
if _, _, err := d.stateStoreGrantToken(&workflow.Task{ID: 42}); err == nil {
t.Fatal("stateStoreGrantToken: want error when State Store is configured but no grant issuer is wired")
}
}
func TestStateStoreGrantTokenNoOpWhenStateStoreUnconfigured(t *testing.T) {
d := &Daemon{}
token, revoke, err := d.stateStoreGrantToken(&workflow.Task{ID: 42})
if err != nil || token != "" || revoke == nil {
t.Fatalf("stateStoreGrantToken = (%q, revoke==nil:%v, %v), want (\"\", false, nil)", token, revoke == nil, err)
}
revoke() // must not panic
}
+3 -3
View File
@@ -518,9 +518,9 @@ func TestAcquireTaskContainerFailureParksTaskOnCancelledContext(t *testing.T) {
d.Storage = &errStorage{setupErr: tt.setupErr}
}
ctr, ok := d.acquireTaskContainer(ctx, task, config.Repo{Owner: "acme", Name: "widget"}, workDir)
if ok || ctr != nil {
t.Fatalf("acquireTaskContainer ok = %v, ctr = %v; want false, nil", ok, ctr)
ctr, revoke, ok := d.acquireTaskContainer(ctx, task, config.Repo{Owner: "acme", Name: "widget"}, workDir)
if ok || ctr != nil || revoke != nil {
t.Fatalf("acquireTaskContainer ok = %v, ctr = %v, revoke==nil:%v; want false, nil, true", ok, ctr, revoke == nil)
}
got, err := s.TaskByID(context.Background(), task.ID)
@@ -0,0 +1,60 @@
package staterpc
import (
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/domain/binding"
"github.com/samcharles93/archie-core/internal/store"
)
func TestCaptureListsExceedUnaryMessageLimit(t *testing.T) {
local := store.OpenTest(t)
body := strings.Repeat("x", 256<<10)
for range 20 {
if _, err := local.InsertCapture(t.Context(), store.CapturedEvent{Source: "large", Body: body, Authenticated: true}, 0, 0); err != nil {
t.Fatal(err)
}
}
// ListUndispatchedCaptures only returns sources with an armed binding
// (internal/store/bindings.go), so "large" needs one taken through the
// public draft -> pending_approval -> armed lifecycle.
id, err := local.InsertBinding(t.Context(), binding.Binding{
Name: "large binding", Matcher: binding.Matcher{Source: "large"},
MappingID: 1, Workflow: "implement", Secret: "0123456789abcdef0123456789abcdef",
})
if err != nil {
t.Fatal(err)
}
if err := local.UpdateBinding(t.Context(), binding.Binding{
ID: id, Name: "large binding", Matcher: binding.Matcher{Source: "large"},
MappingID: 1, Workflow: "implement", Secret: "0123456789abcdef0123456789abcdef",
}); err != nil {
t.Fatal(err)
}
if err := local.ApproveBinding(t.Context(), id); err != nil {
t.Fatal(err)
}
remote := remoteContract(t, local)
for _, undispatched := range []bool{false, true} {
var captures []store.CapturedEvent
var err error
if undispatched {
captures, err = remote.ListUndispatchedCaptures(t.Context(), []string{"large"}, 20)
} else {
captures, err = remote.ListCaptures(t.Context(), 20)
}
if err != nil {
t.Errorf("undispatched=%v: %v", undispatched, err)
continue
}
if len(captures) != 20 {
t.Fatalf("undispatched=%v: got %d captures, want 20", undispatched, len(captures))
}
for _, capture := range captures {
if capture.Body != body {
t.Fatal("capture body truncated")
}
}
}
}
+31 -4
View File
@@ -2,6 +2,8 @@ package staterpc
import (
"context"
"errors"
"io"
"time"
"google.golang.org/grpc"
@@ -244,12 +246,25 @@ func (c *Client) InsertCapture(ctx context.Context, ce store.CapturedEvent, rete
return r.Id, nil
}
// ListCaptures calls StreamCaptures, not the deprecated unary ListCaptures
// RPC: a batch of large capture bodies in one unary response can exceed
// gRPC's 4MiB message cap (docs/prds/state-store-contract.md).
func (c *Client) ListCaptures(ctx context.Context, limit int) ([]store.CapturedEvent, error) {
r, err := c.client.ListCaptures(ctx, &pb.ListCapturesRequest{Limit: int64(limit)})
stream, err := c.client.StreamCaptures(ctx, &pb.StreamCapturesRequest{Limit: int64(limit)})
if err != nil {
return nil, unmapError(err)
}
return mapValues(r.Captures, capturedEventValue), nil
var captures []store.CapturedEvent
for {
r, err := stream.Recv()
if errors.Is(err, io.EOF) {
return captures, nil
}
if err != nil {
return nil, unmapError(err)
}
captures = append(captures, capturedEventValue(r.Capture))
}
}
// Mapping
@@ -352,12 +367,24 @@ func (c *Client) RecordDispatch(ctx context.Context, bindingID, bindingVersion,
return unmapError(err)
}
// ListUndispatchedCaptures calls StreamUndispatchedCaptures; see ListCaptures
// above.
func (c *Client) ListUndispatchedCaptures(ctx context.Context, sources []string, limit int) ([]store.CapturedEvent, error) {
r, err := c.client.ListUndispatchedCaptures(ctx, &pb.ListUndispatchedCapturesRequest{Sources: sources, Limit: int64(limit)})
stream, err := c.client.StreamUndispatchedCaptures(ctx, &pb.StreamUndispatchedCapturesRequest{Sources: sources, Limit: int64(limit)})
if err != nil {
return nil, unmapError(err)
}
return mapValues(r.Captures, capturedEventValue), nil
var captures []store.CapturedEvent
for {
r, err := stream.Recv()
if errors.Is(err, io.EOF) {
return captures, nil
}
if err != nil {
return nil, unmapError(err)
}
captures = append(captures, capturedEventValue(r.Capture))
}
}
// BindingTaskCreator
@@ -38,6 +38,7 @@ func timeSeconds(s int64) time.Duration { return time.Duration(s) * time.Second
// codes.Unavailable) exactly as their daemon-side consumers already treat a
// nil Mappings/Bindings/BindingDispatcher/BindingTaskCreator as "disabled".
type Deps struct {
Grants *TaskGrants
Tasks store.TaskStore
Captures store.CaptureStore
Mappings store.MappingStore
@@ -112,6 +113,9 @@ func (s *server) Transition(ctx context.Context, r *pb.TransitionRequest) (*pb.T
}
func (s *server) Update(ctx context.Context, r *pb.UpdateRequest) (*pb.UpdateResponse, error) {
if r.Task == nil {
return nil, status.Error(codes.InvalidArgument, "task is required")
}
if err := s.deps.Tasks.Update(ctx, taskValue(r.Task)); err != nil {
return nil, s.logErr("Update", err)
}
@@ -302,6 +306,27 @@ func (s *server) ListCaptures(ctx context.Context, r *pb.ListCapturesRequest) (*
return &pb.ListCapturesResponse{Captures: mapValues(captures, capturedEventProto)}, nil
}
// StreamCaptures supersedes ListCaptures: a batch of large capture bodies in
// one unary response can exceed gRPC's 4MiB message cap
// (docs/prds/state-store-contract.md). ListCaptures stays implemented,
// unmodified, so an old client/server pairing mid-rollout keeps working.
func (s *server) StreamCaptures(r *pb.StreamCapturesRequest, stream pb.StateStoreService_StreamCapturesServer) error {
cs, err := s.capture()
if err != nil {
return err
}
captures, err := cs.ListCaptures(stream.Context(), int(r.Limit))
if err != nil {
return s.logErr("StreamCaptures", err)
}
for _, c := range captures {
if err := stream.Send(&pb.StreamCapturesResponse{Capture: capturedEventProto(c)}); err != nil {
return err
}
}
return nil
}
// Mapping
func (s *server) mapping() (store.MappingStore, error) {
@@ -481,6 +506,24 @@ func (s *server) ListUndispatchedCaptures(ctx context.Context, r *pb.ListUndispa
return &pb.ListUndispatchedCapturesResponse{Captures: mapValues(captures, capturedEventProto)}, nil
}
// StreamUndispatchedCaptures supersedes ListUndispatchedCaptures; see
// StreamCaptures above.
func (s *server) StreamUndispatchedCaptures(r *pb.StreamUndispatchedCapturesRequest, stream pb.StateStoreService_StreamUndispatchedCapturesServer) error {
if s.deps.BindingDispatcher == nil {
return errBindingDispatchUnavailable
}
captures, err := s.deps.BindingDispatcher.ListUndispatchedCaptures(stream.Context(), r.Sources, int(r.Limit))
if err != nil {
return s.logErr("StreamUndispatchedCaptures", err)
}
for _, c := range captures {
if err := stream.Send(&pb.StreamUndispatchedCapturesResponse{Capture: capturedEventProto(c)}); err != nil {
return err
}
}
return nil
}
// BindingTaskCreator
func (s *server) EnqueueBindingTask(ctx context.Context, r *pb.EnqueueBindingTaskRequest) (*pb.EnqueueBindingTaskResponse, error) {
@@ -0,0 +1,217 @@
package staterpc
import (
"context"
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"encoding/hex"
"sync"
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/status"
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
"github.com/samcharles93/archie-core/internal/domain/workflow"
)
// TaskGrants lives in the State Store process. Restart invalidates all worker
// grants; administrative credentials are never sent to workers.
type TaskGrants struct {
mu sync.Mutex
active map[int64]taskGrant
}
type taskGrant struct {
digest [32]byte
expires time.Time
}
func (g *TaskGrants) register(taskID int64, token string, lifetime time.Duration) error {
if taskID <= 0 || len(token) != 64 || lifetime <= 0 || lifetime > 7*24*time.Hour {
return status.Error(codes.InvalidArgument, "invalid task grant")
}
if _, err := hex.DecodeString(token); err != nil {
return status.Error(codes.InvalidArgument, "invalid task grant")
}
g.mu.Lock()
defer g.mu.Unlock()
if g.active == nil {
g.active = make(map[int64]taskGrant)
}
now := time.Now()
for id, grant := range g.active {
if !now.Before(grant.expires) {
delete(g.active, id)
}
}
g.active[taskID] = taskGrant{digest: sha256.Sum256([]byte(token)), expires: now.Add(lifetime)}
return nil
}
func (g *TaskGrants) revoke(token string) {
digest := sha256.Sum256([]byte(token))
g.mu.Lock()
defer g.mu.Unlock()
for id, grant := range g.active {
if grant.digest == digest {
delete(g.active, id)
}
}
}
// requestToken extracts the bearer token from ctx's metadata, if any.
func requestToken(ctx context.Context) string {
md, _ := metadata.FromIncomingContext(ctx)
if tokens := md.Get(tokenMetadataKey); len(tokens) > 0 {
return tokens[0]
}
return ""
}
// taskFor resolves token to the task ID it was issued for, or 0 if the token
// is unknown, expired, or empty.
func (g *TaskGrants) taskFor(token string) int64 {
if token == "" {
return 0
}
digest := sha256.Sum256([]byte(token))
g.mu.Lock()
defer g.mu.Unlock()
now := time.Now()
for id, grant := range g.active {
if grant.digest == digest && now.Before(grant.expires) {
return id
}
}
return 0
}
// authorizesTaskScopedCall reports whether req -- a call to one of the three
// workflow.Store RPCs a task grant may ever authorize -- targets taskID.
// Every other RPC (including RegisterTaskGrant/RevokeTaskGrant themselves)
// falls through to false: a task grant can only ever narrow, never expand.
func authorizesTaskScopedCall(fullMethod string, req any, taskID int64) bool {
switch fullMethod {
case pb.StateStoreService_Update_FullMethodName:
r, ok := req.(*pb.UpdateRequest)
return ok && r.Task != nil && r.Task.Id == taskID
case pb.StateStoreService_Transition_FullMethodName:
r, ok := req.(*pb.TransitionRequest)
return ok && r.TaskId == taskID
case pb.StateStoreService_InsertEvent_FullMethodName:
r, ok := req.(*pb.InsertEventRequest)
return ok && r.Event != nil && r.Event.TaskId == taskID
default:
return false
}
}
// UnaryInterceptor separates administrator access from task-scoped worker
// access. A tokenless listener is permitted only on loopback by composition.
// Supplied worker tokens are still validated on loopback.
func (g *TaskGrants) UnaryInterceptor(adminToken string) grpc.UnaryServerInterceptor {
return func(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
token := requestToken(ctx)
if (adminToken == "" && token == "") || (adminToken != "" && subtle.ConstantTimeCompare([]byte(token), []byte(adminToken)) == 1) {
return handler(ctx, req)
}
if token == "" {
return nil, status.Error(codes.Unauthenticated, "missing state store token")
}
taskID := g.taskFor(token)
if taskID == 0 {
return nil, status.Error(codes.Unauthenticated, "invalid state store token")
}
if !authorizesTaskScopedCall(info.FullMethod, req, taskID) {
return nil, status.Error(codes.PermissionDenied, "task grant does not authorize this operation")
}
return handler(ctx, req)
}
}
// StreamInterceptor admits only administrators to store read streams.
func (g *TaskGrants) StreamInterceptor(adminToken string) grpc.StreamServerInterceptor {
return func(srv any, stream grpc.ServerStream, _ *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
md, _ := metadata.FromIncomingContext(stream.Context())
tokens := md.Get(tokenMetadataKey)
if adminToken == "" && len(tokens) == 0 {
return handler(srv, stream)
}
if len(tokens) > 0 && adminToken != "" && subtle.ConstantTimeCompare([]byte(tokens[0]), []byte(adminToken)) == 1 {
return handler(srv, stream)
}
return status.Error(codes.PermissionDenied, "task grant does not authorize streaming reads")
}
}
func (s *server) RegisterTaskGrant(_ context.Context, r *pb.RegisterTaskGrantRequest) (*pb.RegisterTaskGrantResponse, error) {
if s.deps.Grants == nil {
return nil, status.Error(codes.Unavailable, "task grants unavailable")
}
if r.LifetimeSeconds <= 0 || r.LifetimeSeconds > 7*24*60*60 {
return nil, status.Error(codes.InvalidArgument, "invalid task grant lifetime")
}
if err := s.deps.Grants.register(r.TaskId, r.Token, time.Duration(r.LifetimeSeconds)*time.Second); err != nil {
return nil, err
}
return &pb.RegisterTaskGrantResponse{}, nil
}
func (s *server) RevokeTaskGrant(_ context.Context, r *pb.RevokeTaskGrantRequest) (*pb.RevokeTaskGrantResponse, error) {
if s.deps.Grants == nil {
return nil, status.Error(codes.Unavailable, "task grants unavailable")
}
s.deps.Grants.revoke(r.Token)
return &pb.RevokeTaskGrantResponse{}, nil
}
// RegisterTaskGrant creates fresh random material at the daemon and registers
// it at the remote authority before starting the container.
func (c *Client) RegisterTaskGrant(ctx context.Context, taskID int64, lifetime time.Duration) (string, error) {
var bytes [32]byte
if _, err := rand.Read(bytes[:]); err != nil {
return "", err
}
token := hex.EncodeToString(bytes[:])
_, err := c.client.RegisterTaskGrant(ctx, &pb.RegisterTaskGrantRequest{TaskId: taskID, Token: token, LifetimeSeconds: int64(lifetime / time.Second)})
if err != nil {
return "", unmapError(err)
}
return token, nil
}
func (c *Client) RevokeTaskGrant(ctx context.Context, token string) error {
_, err := c.client.RevokeTaskGrant(ctx, &pb.RevokeTaskGrantRequest{Token: token})
return unmapError(err)
}
// defaultGrantLifetime bounds how long an unrevoked grant stays valid if the
// daemon crashes before its deferred revoke runs. It is generous relative to
// any realistic task run, not a task timeout -- the server's own register
// additionally caps any requested lifetime at 7 days.
const defaultGrantLifetime = 24 * time.Hour
// GrantIssuer implements daemon.StateStoreGrantIssuer over a *Client,
// registering a fresh per-task credential at the remote State Store before a
// container starts and revoking it when the daemon releases the container.
type GrantIssuer struct {
Client *Client
}
func (g *GrantIssuer) Issue(task *workflow.Task) (string, func(), error) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
token, err := g.Client.RegisterTaskGrant(ctx, task.ID, defaultGrantLifetime)
if err != nil {
return "", nil, err
}
return token, func() {
revokeCtx, revokeCancel := context.WithTimeout(context.Background(), 10*time.Second)
defer revokeCancel()
_ = g.Client.RevokeTaskGrant(revokeCtx, token)
}, nil
}
@@ -0,0 +1,134 @@
package staterpc
import (
"context"
"net"
"testing"
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
"google.golang.org/grpc/test/bufconn"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/store"
)
// grantsServer wires TaskGrants' Unary/Stream interceptors -- the same
// composition state_store.go's stateStoreServerOpts uses for a non-loopback
// listener -- so tests can dial with an admin token, a task grant, or
// nothing.
func grantsServer(t *testing.T, adminToken string) (grants *TaskGrants, dial func(t *testing.T, token string) *Client) {
t.Helper()
grants = &TaskGrants{}
listener := bufconn.Listen(1 << 20)
local := store.OpenTest(t)
server := grpc.NewServer(
grpc.ChainUnaryInterceptor(grants.UnaryInterceptor(adminToken)),
grpc.ChainStreamInterceptor(grants.StreamInterceptor(adminToken)),
)
RegisterServer(server, Deps{Tasks: local, Grants: grants})
go func() { _ = server.Serve(listener) }()
t.Cleanup(func() { server.Stop(); _ = listener.Close() })
dial = func(t *testing.T, token string) *Client {
t.Helper()
opts := []grpc.DialOption{
grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithContextDialer(func(ctx context.Context, _ string) (net.Conn, error) { return listener.DialContext(ctx) }),
}
if token != "" {
opts = append(opts, grpc.WithUnaryInterceptor(UnaryClientTokenInterceptor(token)))
}
conn, err := grpc.NewClient("passthrough:///state", opts...)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = conn.Close() })
return NewClient(conn)
}
return grants, dial
}
// TestTaskGrantScopesWorkerToItsOwnThreeRPCs is the finding #1 regression:
// a container's task-scoped credential must authorize only Update/
// Transition/InsertEvent on its own task ID, never the admin-only surface
// (StatusCounts here stands in for any of the other ~37 RPCs) and never
// another task's ID.
func TestTaskGrantScopesWorkerToItsOwnThreeRPCs(t *testing.T) {
const adminToken = "daemon-admin-token"
grants, dial := grantsServer(t, adminToken)
admin := dial(t, adminToken)
ctx := t.Context()
taskA, err := admin.EnqueueChatTask(ctx, "acme", "widget", "a", "body", "implement", "")
if err != nil {
t.Fatal(err)
}
taskB, err := admin.EnqueueChatTask(ctx, "acme", "widget", "b", "body", "implement", "")
if err != nil {
t.Fatal(err)
}
// The daemon (never a worker) mints task grants with its own
// administrative credential, mirroring staterpc.GrantIssuer.Issue.
workerToken, err := admin.RegisterTaskGrant(ctx, taskA.ID, time.Hour)
if err != nil {
t.Fatalf("RegisterTaskGrant: %v", err)
}
_ = grants // grants map is exercised indirectly through the interceptor
workerA := dial(t, workerToken)
if err := workerA.Transition(ctx, taskA.ID, taskA.Status, "running", "started"); err != nil {
t.Fatalf("task grant should authorize Transition on its own task: %v", err)
}
if _, err := workerA.InsertEvent(ctx, events.Event{TaskID: taskA.ID, Kind: "log"}); err != nil {
t.Fatalf("task grant should authorize InsertEvent on its own task: %v", err)
}
if err := workerA.Update(ctx, &workflow.Task{ID: taskA.ID, Owner: "acme", Repo: "widget"}); err != nil {
t.Fatalf("task grant should authorize Update on its own task: %v", err)
}
if err := workerA.Transition(ctx, taskB.ID, taskB.Status, "running", "started"); err == nil {
t.Fatal("task grant must not authorize another task's Transition")
}
if _, err := workerA.StatusCounts(ctx); err == nil {
t.Fatal("task grant must not authorize an admin-only RPC")
}
if _, err := workerA.ListCaptures(ctx, 10); err == nil {
t.Fatal("task grant must not authorize the streaming capture surface")
}
if err := admin.RevokeTaskGrant(ctx, workerToken); err != nil {
t.Fatalf("RevokeTaskGrant: %v", err)
}
if err := workerA.Transition(ctx, taskA.ID, "running", "waiting", "revoked check"); err == nil {
t.Fatal("a revoked task grant must be rejected")
}
}
func TestOnlyAdminCanRegisterOrRevokeTaskGrants(t *testing.T) {
const adminToken = "daemon-admin-token"
_, dial := grantsServer(t, adminToken)
ctx := t.Context()
admin := dial(t, adminToken)
taskA, err := admin.EnqueueChatTask(ctx, "acme", "widget", "a", "body", "implement", "")
if err != nil {
t.Fatal(err)
}
workerToken, err := admin.RegisterTaskGrant(ctx, taskA.ID, time.Hour)
if err != nil {
t.Fatal(err)
}
worker := dial(t, workerToken)
if _, err := worker.RegisterTaskGrant(ctx, taskA.ID, time.Hour); err == nil {
t.Fatal("a task-scoped grant must not be able to mint further grants")
}
if err := worker.RevokeTaskGrant(ctx, workerToken); err == nil {
t.Fatal("a task-scoped grant must not be able to revoke grants")
}
}
+41 -2
View File
@@ -12,6 +12,9 @@ import "google/protobuf/timestamp.proto";
// the same *store.Store implementation; the proto bypasses the Go
// interfacebloat cap (max 8), like gateway.v1.ChatService does.
service StateStoreService {
// Administrative task credential lifecycle. Worker credentials cannot call these.
rpc RegisterTaskGrant(RegisterTaskGrantRequest) returns (RegisterTaskGrantResponse);
rpc RevokeTaskGrant(RevokeTaskGrantRequest) returns (RevokeTaskGrantResponse);
// Lifecycle
rpc EnqueueIssue(EnqueueIssueRequest) returns (EnqueueIssueResponse);
rpc EnqueueChatTask(EnqueueChatTaskRequest) returns (EnqueueChatTaskResponse);
@@ -45,7 +48,17 @@ service StateStoreService {
// Capture
rpc InsertCapture(InsertCaptureRequest) returns (InsertCaptureResponse);
rpc ListCaptures(ListCapturesRequest) returns (ListCapturesResponse);
// ListCaptures is superseded by StreamCaptures (kept, unmodified, so an
// in-flight rolling deploy's old client/server pairing keeps working --
// buf breaking forbids removing or reshaping an existing RPC). Every
// in-repo caller uses StreamCaptures.
rpc ListCaptures(ListCapturesRequest) returns (ListCapturesResponse) {
option deprecated = true;
}
// StreamCaptures returns one capture per message: a batch of large capture
// bodies can exceed gRPC's 4MiB unary message cap
// (docs/prds/state-store-contract.md).
rpc StreamCaptures(StreamCapturesRequest) returns (stream StreamCapturesResponse);
// Mapping
rpc InsertMapping(InsertMappingRequest) returns (InsertMappingResponse);
@@ -65,12 +78,29 @@ service StateStoreService {
// Dispatch
rpc ArmedBindingsForSource(ArmedBindingsForSourceRequest) returns (ArmedBindingsForSourceResponse);
rpc RecordDispatch(RecordDispatchRequest) returns (RecordDispatchResponse);
rpc ListUndispatchedCaptures(ListUndispatchedCapturesRequest) returns (ListUndispatchedCapturesResponse);
// ListUndispatchedCaptures is superseded by StreamUndispatchedCaptures; see
// ListCaptures above.
rpc ListUndispatchedCaptures(ListUndispatchedCapturesRequest) returns (ListUndispatchedCapturesResponse) {
option deprecated = true;
}
rpc StreamUndispatchedCaptures(StreamUndispatchedCapturesRequest) returns (stream StreamUndispatchedCapturesResponse);
// BindingTaskCreator
rpc EnqueueBindingTask(EnqueueBindingTaskRequest) returns (EnqueueBindingTaskResponse);
}
// Task mirrors internal/domain/workflow.Task.
message RegisterTaskGrantRequest {
int64 task_id = 1;
string token = 2;
int64 lifetime_seconds = 3;
}
message RegisterTaskGrantResponse {}
message RevokeTaskGrantRequest {
string token = 1;
}
message RevokeTaskGrantResponse {}
// Task mirrors internal/domain/workflow.Task.
message Task {
int64 id = 1;
@@ -328,6 +358,9 @@ message InsertCaptureResponse { int64 id = 1; }
message ListCapturesRequest { int64 limit = 1; }
message ListCapturesResponse { repeated CapturedEvent captures = 1; }
message StreamCapturesRequest { int64 limit = 1; }
// Streamed one capture per message; see StreamCaptures above.
message StreamCapturesResponse { CapturedEvent capture = 1; }
message InsertMappingRequest { Mapping mapping = 1; }
message InsertMappingResponse { int64 id = 1; }
@@ -384,6 +417,12 @@ message ListUndispatchedCapturesRequest {
int64 limit = 2;
}
message ListUndispatchedCapturesResponse { repeated CapturedEvent captures = 1; }
message StreamUndispatchedCapturesRequest {
repeated string sources = 1;
int64 limit = 2;
}
// Streamed one capture per message; see StreamUndispatchedCaptures above.
message StreamUndispatchedCapturesResponse { CapturedEvent capture = 1; }
message EnqueueBindingTaskRequest {
string owner = 1;