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:
1 parent
33751abe4e
commit
8fef2e7eed
21 files changed
+1917
-596
No files matched your search
+18
-8
@@ -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:
|
||||
|
||||
@@ -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"
|
||||
@@ -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,
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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
@@ -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",
|
||||
}
|
||||
@@ -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
@@ -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)
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
Reference in new issue
Block a user