The State Store wire described a provider's class, base URL and key variable but never where its key lives, so every provider reached the daemon credential-less. A task then built its runtime with no key: the egress session had nothing to bind and the agent parked on 'APIKey is required'. Carry api_key_engine and api_key_key alongside the provider. They are a reference, not a secret; the key is still resolved daemon-side and never travels to a container.
1425 lines
51 KiB
Go
1425 lines
51 KiB
Go
// Package staterpc adapts the State Store contract
|
|
// (internal/domain/storecontract's producer-owned surfaces plus the
|
|
// consumer-owned workflow.Store) to gRPC.
|
|
package staterpc
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"log/slog"
|
|
"strings"
|
|
"time"
|
|
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1"
|
|
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
|
|
"github.com/samcharles93/archie-core/internal/domain/access"
|
|
"github.com/samcharles93/archie-core/internal/domain/alert"
|
|
"github.com/samcharles93/archie-core/internal/domain/binding"
|
|
"github.com/samcharles93/archie-core/internal/domain/identity"
|
|
"github.com/samcharles93/archie-core/internal/domain/mapping"
|
|
"github.com/samcharles93/archie-core/internal/domain/org"
|
|
"github.com/samcharles93/archie-core/internal/domain/source"
|
|
"github.com/samcharles93/archie-core/internal/domain/storecontract"
|
|
"github.com/samcharles93/archie-core/internal/domain/storepkg"
|
|
"github.com/samcharles93/archie-core/internal/domain/usage"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
|
|
"github.com/samcharles93/archie-core/internal/logging"
|
|
"github.com/samcharles93/archie-core/internal/taskstate"
|
|
)
|
|
|
|
// Unavailable-capability errors, mirroring gatewayrpc's missing-session-store
|
|
// pattern: a nil optional Deps field maps to codes.Unavailable rather than a
|
|
// nil-pointer panic.
|
|
var (
|
|
errCaptureUnavailable = status.Error(codes.Unavailable, "capture store unavailable")
|
|
errConfigSnapshotsUnavailable = status.Error(codes.Unavailable, "config snapshot store unavailable")
|
|
errChannelStatusUnavailable = status.Error(codes.Unavailable, "channel status store unavailable")
|
|
errApplyStatusUnavailable = status.Error(codes.Unavailable, "apply status store unavailable")
|
|
errPresenceUnavailable = status.Error(codes.Unavailable, "presence store unavailable")
|
|
errRefusalsUnavailable = status.Error(codes.Unavailable, "capture refusal store unavailable")
|
|
errMappingUnavailable = status.Error(codes.Unavailable, "mapping store unavailable")
|
|
errBindingUnavailable = status.Error(codes.Unavailable, "binding store unavailable")
|
|
errSourceUnavailable = status.Error(codes.Unavailable, "source store unavailable")
|
|
errBindingDispatchUnavailable = status.Error(codes.Unavailable, "binding dispatcher unavailable")
|
|
errBindingTaskCreatorUnavailable = status.Error(codes.Unavailable, "binding task creator unavailable")
|
|
errPlaybookDispatcherUnavailable = status.Error(codes.Unavailable, "playbook dispatcher unavailable")
|
|
errWorkflowCallerUnavailable = status.Error(codes.Unavailable, "workflow caller unavailable")
|
|
// errTaskLogsUnavailable reports that this process cannot read task logs.
|
|
errTaskLogsUnavailable = status.Error(codes.Unavailable, msgTaskLogsUnavailable)
|
|
)
|
|
|
|
func timeSeconds(s int64) time.Duration { return time.Duration(s) * time.Second }
|
|
|
|
// taskLogChunkBytes bounds one streamed message. A log file rotates at
|
|
// logging.DefaultMaxSizeMB, well past gRPC's 4MiB unary cap, so the download
|
|
// is served in pieces (the same reason captures are streamed)
|
|
// and the pieces must be small enough to carry.
|
|
const taskLogChunkBytes = 256 << 10
|
|
|
|
// Deps groups the store surfaces the StateStore service fronts. TaskStore is
|
|
// required; the rest are optional (nil disables that group's RPCs, returning
|
|
// codes.Unavailable) exactly as their daemon-side consumers already treat a
|
|
// nil Mappings/Bindings/BindingDispatcher/BindingTaskCreator as "disabled".
|
|
type Deps struct {
|
|
ControlPlane controlpb.ControlPlaneServiceServer
|
|
Identities identity.Repository
|
|
Accounts identity.Accounts
|
|
// SubjectBindings fronts the subject-binding surface, which only the
|
|
// authenticating path needs. Unset means this process cannot resolve a
|
|
// verified subject, and the RPCs answer Unavailable rather than pretending.
|
|
SubjectBindings identity.SubjectBinding
|
|
// PersonalTokens stores the caller-owned personal API tokens. Optional:
|
|
// nil answers Unavailable.
|
|
PersonalTokens identity.PersonalTokenStore
|
|
Grants *TaskGrants
|
|
Packages storepkg.Manager
|
|
Tasks storecontract.TaskStore
|
|
Captures storecontract.CaptureStore
|
|
ConfigSnapshots storecontract.ConfigSnapshotStore
|
|
// ChannelStatus is the channel runtime state the process hosting the channels
|
|
// reports. Optional: nil disables the pair with codes.Unavailable, which is
|
|
// the honest answer for a store service no messaging process is writing to.
|
|
ChannelStatus storecontract.ChannelStatusStore
|
|
ApplyStatus storecontract.ApplyStatusStore
|
|
Presence storecontract.PresenceStore
|
|
Refusals storecontract.CaptureRefusalStore
|
|
Mappings storecontract.MappingStore
|
|
EventTypes storecontract.EventTypeStore
|
|
// MappingMatches counts the events each mapping resolved. Optional: nil
|
|
// answers RecordMappingMatch with codes.Unavailable.
|
|
MappingMatches storecontract.MappingMatchRecorder
|
|
Bindings storecontract.BindingStore
|
|
Sources storecontract.SourceStore
|
|
BindingDispatcher storecontract.BindingDispatcher
|
|
BindingTaskCreator storecontract.BindingTaskCreator
|
|
// WorkflowCalls is the workflow.call surface:
|
|
// the workflow engine's task.Caller over this contract. Optional: nil
|
|
// answers both RPCs with codes.Unavailable, which is the honest answer
|
|
// for a store that owns no task table.
|
|
WorkflowCalls storecontract.WorkflowCaller
|
|
// Steps is the step-execution write surface:
|
|
// the guarded row writes the
|
|
// workflow engine's run credential calls. Optional: nil answers both RPCs
|
|
// with codes.Unavailable.
|
|
Steps storecontract.StepRecorder
|
|
// Usage appends model usage records. Optional: nil answers RecordUsage
|
|
// with codes.Unavailable.
|
|
Usage usage.Recorder
|
|
// OrgModels answers an org's effective model aliases and own providers.
|
|
// Optional: nil answers TaskModels with codes.Unavailable.
|
|
OrgModels func(ctx context.Context, orgID string) (map[string]string, map[string]config.Provider, error)
|
|
// OrgInstructions answers the instance instructions and orgID's own.
|
|
OrgInstructions func(ctx context.Context, orgID string) (instance, organisation string, err error)
|
|
// Canceller is the one cancel path:
|
|
// an operator action's guarded write over the execution and its steps.
|
|
// Optional: nil answers the RPC with codes.Unavailable.
|
|
Canceller storecontract.ExecutionCanceller
|
|
// StepReader lists an execution's recorded steps for the dashboard/API:
|
|
// a plain read, never
|
|
// task-scoped-grant callable. Optional: nil answers ListSteps with
|
|
// codes.Unavailable.
|
|
StepReader storecontract.StepReader
|
|
// HarnessSecrets persists harness OAuth token sets.
|
|
// Optional: nil
|
|
// answers both RPCs with codes.Unavailable.
|
|
HarnessSecrets storecontract.HarnessSecretStore
|
|
// PlaybookDispatcher is the side-effecting-action idempotency ledger.
|
|
// Optional: nil disables the
|
|
// two playbook dispatch RPCs with codes.Unavailable.
|
|
PlaybookDispatcher storecontract.PlaybookDispatcher
|
|
// Principals assembles the access principal for one identity: the org it
|
|
// serves and its memberships. Optional: nil answers GetPrincipal with
|
|
// codes.Unavailable.
|
|
Principals access.PrincipalSource
|
|
// RootIdentity is the identity a task with no identity name runs as.
|
|
RootIdentity identity.IdentityID
|
|
// Policies is the stored policy chain.
|
|
// Optional: nil answers the access RPCs with codes.Unavailable. The reset
|
|
// surface is deliberately not an RPC: `archie-state-store access reset` runs on the
|
|
// State Store host, never over the network.
|
|
Policies access.PolicyStore
|
|
// Denials records and lists denial records. Optional: nil disables the
|
|
// pair with codes.Unavailable.
|
|
Denials access.DenialStore
|
|
// Alerts is the operator alert store. Optional: nil answers the alert
|
|
// RPCs with codes.Unavailable.
|
|
Alerts alert.Store
|
|
// Orgs persists orgs, workspaces, memberships and agent assignments.
|
|
// Optional: nil answers the org RPCs with codes.Unavailable.
|
|
Orgs org.Repository
|
|
// TaskLogs reads task attempt logs. Nil answers ReadTaskLog with
|
|
// Unavailable.
|
|
TaskLogs storecontract.TaskLogStore
|
|
LogFeed *logging.Feed
|
|
Log *slog.Logger
|
|
}
|
|
|
|
type server struct {
|
|
pb.UnimplementedStateStoreServiceServer
|
|
deps Deps
|
|
}
|
|
|
|
// RegisterServer registers the StateStore gRPC service against registrar,
|
|
// backed by deps. Optionally wrap registrar's interceptor chain with
|
|
// TokenInterceptor for the bridge-address (agent-consumed) topology; the caller
|
|
// decides.
|
|
func RegisterServer(registrar grpc.ServiceRegistrar, deps Deps) {
|
|
if deps.Log == nil {
|
|
deps.Log = slog.New(slog.DiscardHandler)
|
|
}
|
|
pb.RegisterStateStoreServiceServer(registrar, &server{deps: deps})
|
|
if deps.ControlPlane != nil {
|
|
controlpb.RegisterControlPlaneServiceServer(registrar, deps.ControlPlane)
|
|
}
|
|
}
|
|
|
|
func (s *server) logErr(rpc string, err error) error {
|
|
if err != nil {
|
|
s.deps.Log.Error("staterpc call failed", "rpc", rpc, "err", err)
|
|
}
|
|
return mapError(err)
|
|
}
|
|
|
|
// validationFailure maps a domain validation error to InvalidArgument.
|
|
func validationFailure(err error) error {
|
|
return status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
|
|
// Lifecycle
|
|
|
|
func (s *server) EnqueueIssue(ctx context.Context, r *pb.EnqueueIssueRequest) (*pb.EnqueueIssueResponse, error) {
|
|
inserted, err := s.deps.Tasks.EnqueueIssue(ctx, r.Owner, r.Repo, int(r.Number), r.Title, r.Body, r.Labels, r.Identity)
|
|
if err != nil {
|
|
return nil, s.logErr("EnqueueIssue", err)
|
|
}
|
|
return &pb.EnqueueIssueResponse{Inserted: inserted}, nil
|
|
}
|
|
|
|
func (s *server) ActiveTasksByOrigin(ctx context.Context, r *pb.ActiveTasksByOriginRequest) (*pb.ActiveTasksByOriginResponse, error) {
|
|
tasks, err := s.deps.Tasks.ActiveTasksByOrigin(ctx, r.Origin)
|
|
if err != nil {
|
|
return nil, s.logErr("ActiveTasksByOrigin", err)
|
|
}
|
|
out := make([]*pb.Task, 0, len(tasks))
|
|
for _, t := range tasks {
|
|
out = append(out, taskProto(t))
|
|
}
|
|
return &pb.ActiveTasksByOriginResponse{Tasks: out}, nil
|
|
}
|
|
|
|
func (s *server) UnpostedOutcomes(ctx context.Context, _ *pb.UnpostedOutcomesRequest) (*pb.UnpostedOutcomesResponse, error) {
|
|
tasks, err := s.deps.Tasks.UnpostedOutcomes(ctx)
|
|
if err != nil {
|
|
return nil, s.logErr("UnpostedOutcomes", err)
|
|
}
|
|
out := make([]*pb.Task, 0, len(tasks))
|
|
for _, t := range tasks {
|
|
out = append(out, taskProto(t))
|
|
}
|
|
return &pb.UnpostedOutcomesResponse{Tasks: out}, nil
|
|
}
|
|
|
|
func (s *server) MarkOutcomePosted(ctx context.Context, r *pb.MarkOutcomePostedRequest) (*pb.MarkOutcomePostedResponse, error) {
|
|
if err := s.deps.Tasks.MarkOutcomePosted(ctx, r.TaskId); err != nil {
|
|
return nil, s.logErr("MarkOutcomePosted", err)
|
|
}
|
|
return &pb.MarkOutcomePostedResponse{}, nil
|
|
}
|
|
|
|
func (s *server) EnqueueChatTask(ctx context.Context, r *pb.EnqueueChatTaskRequest) (*pb.EnqueueChatTaskResponse, error) {
|
|
inputs, err := task.DecodeInputs(r.InputsJson)
|
|
if err != nil {
|
|
return nil, status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
t, err := s.deps.Tasks.EnqueueChatTask(ctx, r.Owner, r.Repo, r.Title, r.Body, r.Workflow, r.Identity, r.Origin, r.DraftYaml, inputs)
|
|
if err != nil {
|
|
return nil, s.logErr("EnqueueChatTask", err)
|
|
}
|
|
return &pb.EnqueueChatTaskResponse{Task: taskProto(t)}, nil
|
|
}
|
|
|
|
func (s *server) ClaimNext(ctx context.Context, _ *pb.ClaimNextRequest) (*pb.ClaimNextResponse, error) {
|
|
t, err := s.deps.Tasks.ClaimNext(ctx)
|
|
if err != nil {
|
|
return nil, s.logErr("ClaimNext", err)
|
|
}
|
|
return &pb.ClaimNextResponse{Task: taskProto(t), Found: t != nil}, nil
|
|
}
|
|
|
|
func (s *server) ClaimByIssue(ctx context.Context, r *pb.ClaimByIssueRequest) (*pb.ClaimByIssueResponse, error) {
|
|
t, err := s.deps.Tasks.ClaimByIssue(ctx, r.Owner, r.Repo, int(r.Number))
|
|
if err != nil {
|
|
return nil, s.logErr("ClaimByIssue", err)
|
|
}
|
|
return &pb.ClaimByIssueResponse{Task: taskProto(t), Found: t != nil}, nil
|
|
}
|
|
|
|
func (s *server) Transition(ctx context.Context, r *pb.TransitionRequest) (*pb.TransitionResponse, error) {
|
|
if err := s.deps.Tasks.Transition(ctx, r.TaskId, r.From, r.To, r.Detail); err != nil {
|
|
return nil, s.logErr("Transition", err)
|
|
}
|
|
return &pb.TransitionResponse{}, nil
|
|
}
|
|
|
|
// StartStep and FinishStep write a step transition and return its event.
|
|
func (s *server) StartStep(ctx context.Context, r *pb.StartStepRequest) (*pb.StartStepResponse, error) {
|
|
if s.deps.Steps == nil {
|
|
return nil, status.Error(codes.Unavailable, "step recorder unavailable")
|
|
}
|
|
stepID, event, err := s.deps.Steps.StartStep(ctx, task.StepStart{
|
|
ExecutionID: r.ExecutionId, Attempt: int(r.Attempt),
|
|
ParentID: r.ParentId, Kind: r.Kind, Name: r.Name,
|
|
CalledExecutionID: r.CalledExecutionId,
|
|
})
|
|
if err != nil {
|
|
return nil, s.logErr("StartStep", err)
|
|
}
|
|
return &pb.StartStepResponse{StepId: stepID, Event: eventProto(event)}, nil
|
|
}
|
|
|
|
// RecordUsage appends one model call's usage record.
|
|
func (s *server) RecordUsage(ctx context.Context, r *pb.RecordUsageRequest) (*pb.RecordUsageResponse, error) {
|
|
if s.deps.Usage == nil {
|
|
return nil, status.Error(codes.Unavailable, "usage recorder unavailable")
|
|
}
|
|
if r.Record == nil {
|
|
return nil, status.Error(codes.InvalidArgument, "record is required")
|
|
}
|
|
record := usageValue(r.Record)
|
|
// The caller never names the org: a task's is its row's, which the store
|
|
// applies; anything else is the calling principal's.
|
|
record.Org = string(org.OrgFromContext(ctx))
|
|
if err := s.deps.Usage.RecordUsage(ctx, record); err != nil {
|
|
return nil, s.logErr("RecordUsage", err)
|
|
}
|
|
return &pb.RecordUsageResponse{}, nil
|
|
}
|
|
|
|
// TaskModels answers what the task's org resolves models against.
|
|
func (s *server) TaskModels(ctx context.Context, r *pb.TaskModelsRequest) (*pb.TaskModelsResponse, error) {
|
|
if s.deps.OrgModels == nil {
|
|
return nil, status.Error(codes.Unavailable, "model aliases unavailable")
|
|
}
|
|
t, err := s.deps.Tasks.TaskByID(ctx, r.TaskId)
|
|
if err != nil {
|
|
return nil, s.logErr("TaskModels", err)
|
|
}
|
|
if t == nil {
|
|
return nil, status.Error(codes.NotFound, "task not found")
|
|
}
|
|
orgID := t.OrgOrDefault()
|
|
aliases, providers, err := s.deps.OrgModels(ctx, orgID)
|
|
if err != nil {
|
|
return nil, s.logErr("TaskModels", err)
|
|
}
|
|
out := make(map[string]*pb.ModelProvider, len(providers))
|
|
for name, p := range providers {
|
|
out[name] = modelProviderToPB(p)
|
|
}
|
|
return &pb.TaskModelsResponse{OrgId: orgID, Aliases: aliases, Providers: out}, nil
|
|
}
|
|
|
|
// TaskInstructions answers the instance and organisation instructions for the
|
|
// task's org.
|
|
func (s *server) TaskInstructions(ctx context.Context, r *pb.TaskInstructionsRequest) (*pb.TaskInstructionsResponse, error) {
|
|
if s.deps.OrgInstructions == nil {
|
|
return nil, status.Error(codes.Unavailable, "instructions unavailable")
|
|
}
|
|
t, err := s.deps.Tasks.TaskByID(ctx, r.TaskId)
|
|
if err != nil {
|
|
return nil, s.logErr("TaskInstructions", err)
|
|
}
|
|
if t == nil {
|
|
return nil, status.Error(codes.NotFound, "task not found")
|
|
}
|
|
instance, organisation, err := s.deps.OrgInstructions(ctx, t.OrgOrDefault())
|
|
if err != nil {
|
|
return nil, s.logErr("TaskInstructions", err)
|
|
}
|
|
return &pb.TaskInstructionsResponse{Instance: instance, Organisation: organisation}, nil
|
|
}
|
|
|
|
// CallerModels answers the aliases the calling principal's org may use.
|
|
func (s *server) CallerModels(ctx context.Context, _ *pb.CallerModelsRequest) (*pb.CallerModelsResponse, error) {
|
|
if s.deps.OrgModels == nil {
|
|
return nil, status.Error(codes.Unavailable, "model aliases unavailable")
|
|
}
|
|
orgID := string(org.OrgFromContext(ctx))
|
|
aliases, _, err := s.deps.OrgModels(ctx, orgID)
|
|
if err != nil {
|
|
return nil, s.logErr("CallerModels", err)
|
|
}
|
|
return &pb.CallerModelsResponse{OrgId: orgID, Aliases: aliases}, nil
|
|
}
|
|
|
|
// CancelExecution is the one cancel path:
|
|
// the store records the cancellation and returns the callees it cancelled
|
|
// with it; the caller delivers it by cancelling the runs' in-memory contexts
|
|
// afterwards.
|
|
func (s *server) CancelExecution(ctx context.Context, r *pb.CancelExecutionRequest) (*pb.CancelExecutionResponse, error) {
|
|
if s.deps.Canceller == nil {
|
|
return nil, status.Error(codes.Unavailable, "execution canceller unavailable")
|
|
}
|
|
ids, err := s.deps.Canceller.CancelExecution(ctx, r.TaskId, r.Reason, r.To)
|
|
if err != nil {
|
|
return nil, s.logErr("CancelExecution", err)
|
|
}
|
|
return &pb.CancelExecutionResponse{CancelledCalleeIds: ids}, nil
|
|
}
|
|
|
|
func (s *server) FinishStep(ctx context.Context, r *pb.FinishStepRequest) (*pb.FinishStepResponse, error) {
|
|
if s.deps.Steps == nil {
|
|
return nil, status.Error(codes.Unavailable, "step recorder unavailable")
|
|
}
|
|
event, err := s.deps.Steps.FinishStep(ctx, task.StepFinish{
|
|
StepID: r.StepId, ExecutionID: r.ExecutionId,
|
|
From: taskstate.StepStatus(r.From), To: taskstate.StepStatus(r.To),
|
|
Detail: r.Detail, TokensUsed: r.TokensUsed, Results: r.Results,
|
|
})
|
|
if err != nil {
|
|
return nil, s.logErr("FinishStep", err)
|
|
}
|
|
return &pb.FinishStepResponse{Event: eventProto(event)}, nil
|
|
}
|
|
|
|
func (s *server) ListSteps(ctx context.Context, r *pb.ListStepsRequest) (*pb.ListStepsResponse, error) {
|
|
if s.deps.StepReader == nil {
|
|
return nil, status.Error(codes.Unavailable, "step reader unavailable")
|
|
}
|
|
steps, err := s.deps.StepReader.ListSteps(ctx, r.ExecutionId, int(r.Attempt))
|
|
if err != nil {
|
|
return nil, s.logErr("ListSteps", err)
|
|
}
|
|
return &pb.ListStepsResponse{Steps: mapValues(steps, stepExecutionProto)}, nil
|
|
}
|
|
|
|
// harnessOrg derives scope from a live run credential or the authenticated caller.
|
|
func (s *server) harnessOrg(ctx context.Context, credential string) (string, error) {
|
|
if credential == "" {
|
|
return string(org.OrgFromContext(ctx)), nil
|
|
}
|
|
if s.deps.Grants == nil || s.deps.Tasks == nil {
|
|
return "", status.Error(codes.Unavailable, "task grants unavailable")
|
|
}
|
|
id, err := s.deps.Grants.taskFor(ctx, credential)
|
|
if err != nil {
|
|
return "", status.Error(codes.Unavailable, "run credentials unavailable")
|
|
}
|
|
if id == 0 {
|
|
return "", status.Error(codes.Unauthenticated, "invalid task grant")
|
|
}
|
|
t, err := s.deps.Tasks.TaskByID(ctx, id)
|
|
if err != nil {
|
|
return "", mapError(err)
|
|
}
|
|
target := t.OrgOrDefault()
|
|
if scope, ok := org.Scope(ctx); ok && string(scope) != target {
|
|
return "", status.Error(codes.PermissionDenied, "harness secret belongs to another org")
|
|
}
|
|
return target, nil
|
|
}
|
|
|
|
func (s *server) GetHarnessSecret(ctx context.Context, r *pb.GetHarnessSecretRequest) (*pb.GetHarnessSecretResponse, error) {
|
|
if s.deps.HarnessSecrets == nil {
|
|
return nil, status.Error(codes.Unavailable, "harness secret store unavailable")
|
|
}
|
|
orgID, err := s.harnessOrg(ctx, r.RunCredential)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
secret, err := s.deps.HarnessSecrets.GetHarnessSecret(ctx, orgID, r.Service)
|
|
if err != nil {
|
|
return nil, s.logErr("GetHarnessSecret", err)
|
|
}
|
|
return &pb.GetHarnessSecretResponse{Secret: harnessSecretProto(secret), Org: orgID}, nil
|
|
}
|
|
|
|
func (s *server) PutHarnessSecret(ctx context.Context, r *pb.PutHarnessSecretRequest) (*pb.PutHarnessSecretResponse, error) {
|
|
if s.deps.HarnessSecrets == nil {
|
|
return nil, status.Error(codes.Unavailable, "harness secret store unavailable")
|
|
}
|
|
value := harnessSecretValue(r.Secret)
|
|
orgID, err := s.harnessOrg(ctx, r.RunCredential)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
value.Org = orgID
|
|
if err := s.deps.HarnessSecrets.PutHarnessSecret(ctx, value); err != nil {
|
|
return nil, s.logErr("PutHarnessSecret", err)
|
|
}
|
|
return &pb.PutHarnessSecretResponse{}, nil
|
|
}
|
|
|
|
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)
|
|
}
|
|
return &pb.UpdateResponse{}, nil
|
|
}
|
|
|
|
func (s *server) Requeue(ctx context.Context, r *pb.RequeueRequest) (*pb.RequeueResponse, error) {
|
|
if err := s.deps.Tasks.Requeue(ctx, r.TaskId, r.FromStatus, r.Workflow); err != nil {
|
|
return nil, s.logErr("Requeue", err)
|
|
}
|
|
return &pb.RequeueResponse{}, nil
|
|
}
|
|
|
|
func (s *server) ParkTask(ctx context.Context, r *pb.ParkTaskRequest) (*pb.ParkTaskResponse, error) {
|
|
if err := s.deps.Tasks.ParkTask(ctx, r.TaskId, r.From, r.Detail, r.Class, r.Blocker); err != nil {
|
|
return nil, s.logErr("ParkTask", err)
|
|
}
|
|
return &pb.ParkTaskResponse{}, nil
|
|
}
|
|
|
|
func (s *server) RecoverStale(ctx context.Context, _ *pb.RecoverStaleRequest) (*pb.RecoverStaleResponse, error) {
|
|
n, err := s.deps.Tasks.RecoverStale(ctx)
|
|
if err != nil {
|
|
return nil, s.logErr("RecoverStale", err)
|
|
}
|
|
return &pb.RecoverStaleResponse{Count: n}, nil
|
|
}
|
|
|
|
// Archive / Retry
|
|
|
|
func (s *server) ArchiveTask(ctx context.Context, r *pb.ArchiveTaskRequest) (*pb.ArchiveTaskResponse, error) {
|
|
eventID, err := s.deps.Tasks.ArchiveTask(ctx, r.TaskId, r.FromStatus, eventValue(r.Audit))
|
|
if err != nil {
|
|
return nil, s.logErr("ArchiveTask", err)
|
|
}
|
|
return &pb.ArchiveTaskResponse{EventId: eventID}, nil
|
|
}
|
|
|
|
func (s *server) RetryTask(ctx context.Context, r *pb.RetryTaskRequest) (*pb.RetryTaskResponse, error) {
|
|
if err := s.deps.Tasks.RetryTask(ctx, r.TaskId, r.FromStatus, r.Workflow, r.RetryMode, task.Resume{From: r.ResumeFrom, After: r.ResumeAfter}, r.CurrentDefinition); err != nil {
|
|
return nil, s.logErr("RetryTask", err)
|
|
}
|
|
return &pb.RetryTaskResponse{}, nil
|
|
}
|
|
|
|
func (s *server) RespondReviewGate(ctx context.Context, r *pb.RespondReviewGateRequest) (*pb.RespondReviewGateResponse, error) {
|
|
if err := s.deps.Tasks.RespondReviewGate(ctx, r.TaskId, r.FromStatus, r.Gate, r.Rereview, int(r.Cap)); err != nil {
|
|
return nil, s.logErr("RespondReviewGate", err)
|
|
}
|
|
return &pb.RespondReviewGateResponse{}, nil
|
|
}
|
|
|
|
func (s *server) BeginRemediation(ctx context.Context, r *pb.BeginRemediationRequest) (*pb.BeginRemediationResponse, error) {
|
|
if err := s.deps.Tasks.BeginRemediation(ctx, r.TaskId, r.Payload); err != nil {
|
|
return nil, s.logErr("BeginRemediation", err)
|
|
}
|
|
return &pb.BeginRemediationResponse{}, nil
|
|
}
|
|
|
|
func (s *server) UpdateReviewPayload(ctx context.Context, r *pb.UpdateReviewPayloadRequest) (*pb.UpdateReviewPayloadResponse, error) {
|
|
if err := s.deps.Tasks.UpdateReviewPayload(ctx, r.TaskId, r.Payload); err != nil {
|
|
return nil, s.logErr("UpdateReviewPayload", err)
|
|
}
|
|
return &pb.UpdateReviewPayloadResponse{}, nil
|
|
}
|
|
|
|
func (s *server) SetReviewCursors(ctx context.Context, r *pb.SetReviewCursorsRequest) (*pb.SetReviewCursorsResponse, error) {
|
|
if err := s.deps.Tasks.SetReviewCursors(ctx, r.TaskId, r.ReviewCursor, r.CommentCursor); err != nil {
|
|
return nil, s.logErr("SetReviewCursors", err)
|
|
}
|
|
return &pb.SetReviewCursorsResponse{}, nil
|
|
}
|
|
|
|
// Queries
|
|
|
|
func (s *server) TaskByIssue(ctx context.Context, r *pb.TaskByIssueRequest) (*pb.TaskByIssueResponse, error) {
|
|
t, err := s.deps.Tasks.TaskByIssue(ctx, r.Owner, r.Repo, int(r.Number))
|
|
if err != nil {
|
|
return nil, s.logErr("TaskByIssue", err)
|
|
}
|
|
return &pb.TaskByIssueResponse{Task: taskProto(t), Found: t != nil}, nil
|
|
}
|
|
|
|
func (s *server) OpenTaskByPR(ctx context.Context, r *pb.OpenTaskByPRRequest) (*pb.OpenTaskByPRResponse, error) {
|
|
t, err := s.deps.Tasks.OpenTaskByPR(ctx, r.Owner, r.Repo, int(r.Number))
|
|
if err != nil {
|
|
return nil, s.logErr("OpenTaskByPR", err)
|
|
}
|
|
return &pb.OpenTaskByPRResponse{Task: taskProto(t), Found: t != nil}, nil
|
|
}
|
|
|
|
func (s *server) TaskByID(ctx context.Context, r *pb.TaskByIDRequest) (*pb.TaskByIDResponse, error) {
|
|
t, err := s.deps.Tasks.TaskByID(ctx, r.TaskId)
|
|
if err != nil {
|
|
return nil, s.logErr("TaskByID", err)
|
|
}
|
|
return &pb.TaskByIDResponse{Task: taskProto(t), Found: t != nil}, nil
|
|
}
|
|
|
|
func (s *server) OpenPRs(ctx context.Context, _ *pb.OpenPRsRequest) (*pb.OpenPRsResponse, error) {
|
|
tasks, err := s.deps.Tasks.OpenPRs(ctx)
|
|
if err != nil {
|
|
return nil, s.logErr("OpenPRs", err)
|
|
}
|
|
out := make([]*pb.Task, len(tasks))
|
|
for i := range tasks {
|
|
out[i] = taskProto(&tasks[i])
|
|
}
|
|
return &pb.OpenPRsResponse{Tasks: out}, nil
|
|
}
|
|
|
|
func (s *server) ClearTerminalTasks(ctx context.Context, _ *pb.ClearTerminalTasksRequest) (*pb.ClearTerminalTasksResponse, error) {
|
|
n, err := s.deps.Tasks.ClearTerminalTasks(ctx)
|
|
if err != nil {
|
|
return nil, s.logErr("ClearTerminalTasks", err)
|
|
}
|
|
return &pb.ClearTerminalTasksResponse{Count: n}, nil
|
|
}
|
|
|
|
func (s *server) Tasks(ctx context.Context, r *pb.TasksRequest) (*pb.TasksResponse, error) {
|
|
tasks, err := s.deps.Tasks.TasksPage(ctx, storecontract.TaskPage{
|
|
Statuses: r.Statuses, Workflow: r.Workflow, Limit: int(r.Limit),
|
|
After: storecontract.TaskCursor{UpdatedAt: timeValue(r.AfterUpdatedAt), ID: r.AfterId},
|
|
})
|
|
if err != nil {
|
|
return nil, s.logErr("Tasks", err)
|
|
}
|
|
out := make([]*pb.Task, len(tasks))
|
|
for i := range tasks {
|
|
out[i] = taskProto(&tasks[i])
|
|
}
|
|
return &pb.TasksResponse{Tasks: out}, nil
|
|
}
|
|
|
|
func (s *server) StatusCounts(ctx context.Context, _ *pb.StatusCountsRequest) (*pb.StatusCountsResponse, error) {
|
|
counts, err := s.deps.Tasks.StatusCounts(ctx)
|
|
if err != nil {
|
|
return nil, s.logErr("StatusCounts", err)
|
|
}
|
|
out := make(map[string]int64, len(counts))
|
|
for k, v := range counts {
|
|
out[k] = int64(v)
|
|
}
|
|
return &pb.StatusCountsResponse{Counts: out}, nil
|
|
}
|
|
|
|
// Events
|
|
|
|
func (s *server) InsertEvent(ctx context.Context, r *pb.InsertEventRequest) (*pb.InsertEventResponse, error) {
|
|
id, err := s.deps.Tasks.InsertEvent(ctx, eventValue(r.Event))
|
|
if err != nil {
|
|
return nil, s.logErr("InsertEvent", err)
|
|
}
|
|
return &pb.InsertEventResponse{Id: id}, nil
|
|
}
|
|
|
|
func (s *server) EventsSince(ctx context.Context, r *pb.EventsSinceRequest) (*pb.EventsSinceResponse, error) {
|
|
evs, err := s.deps.Tasks.EventsSince(ctx, r.SinceId, int(r.Limit))
|
|
if err != nil {
|
|
return nil, s.logErr("EventsSince", err)
|
|
}
|
|
return &pb.EventsSinceResponse{Events: mapValues(evs, eventProto)}, nil
|
|
}
|
|
|
|
func (s *server) TaskEvents(ctx context.Context, r *pb.TaskEventsRequest) (*pb.TaskEventsResponse, error) {
|
|
evs, err := s.deps.Tasks.TaskEvents(ctx, r.TaskId)
|
|
if err != nil {
|
|
return nil, s.logErr("TaskEvents", err)
|
|
}
|
|
return &pb.TaskEventsResponse{Events: mapValues(evs, eventProto)}, nil
|
|
}
|
|
|
|
func (s *server) WorkflowStats(ctx context.Context, _ *pb.WorkflowStatsRequest) (*pb.WorkflowStatsResponse, error) {
|
|
stats, err := s.deps.Tasks.WorkflowStats(ctx)
|
|
if err != nil {
|
|
return nil, s.logErr("WorkflowStats", err)
|
|
}
|
|
return &pb.WorkflowStatsResponse{Stats: mapValues(stats, workflowStatProto)}, nil
|
|
}
|
|
|
|
func (s *server) StageStats(ctx context.Context, _ *pb.StageStatsRequest) (*pb.StageStatsResponse, error) {
|
|
stats, err := s.deps.Tasks.StageStats(ctx)
|
|
if err != nil {
|
|
return nil, s.logErr("StageStats", err)
|
|
}
|
|
return &pb.StageStatsResponse{Stats: mapValues(stats, stageStatProto)}, nil
|
|
}
|
|
|
|
func (s *server) TokensByDay(ctx context.Context, r *pb.TokensByDayRequest) (*pb.TokensByDayResponse, error) {
|
|
tokens, err := s.deps.Tasks.TokensByDay(ctx, int(r.Days))
|
|
if err != nil {
|
|
return nil, s.logErr("TokensByDay", err)
|
|
}
|
|
return &pb.TokensByDayResponse{Tokens: mapValues(tokens, dayTokensProto)}, nil
|
|
}
|
|
|
|
// Capture
|
|
|
|
func (s *server) capture() (storecontract.CaptureStore, error) {
|
|
if s.deps.Captures == nil {
|
|
return nil, errCaptureUnavailable
|
|
}
|
|
return s.deps.Captures, nil
|
|
}
|
|
|
|
func (s *server) applyStatus() (storecontract.ApplyStatusStore, error) {
|
|
if s.deps.ApplyStatus == nil {
|
|
return nil, errApplyStatusUnavailable
|
|
}
|
|
return s.deps.ApplyStatus, nil
|
|
}
|
|
|
|
func (s *server) PutApplyStatus(ctx context.Context, r *pb.PutApplyStatusRequest) (*pb.PutApplyStatusResponse, error) {
|
|
as, err := s.applyStatus()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := as.PutApplyStatus(ctx, applyStatusValue(r.Status)); err != nil {
|
|
return nil, s.logErr("PutApplyStatus", err)
|
|
}
|
|
return &pb.PutApplyStatusResponse{}, nil
|
|
}
|
|
|
|
func (s *server) ListApplyStatus(ctx context.Context, _ *pb.ListApplyStatusRequest) (*pb.ListApplyStatusResponse, error) {
|
|
as, err := s.applyStatus()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
statuses, err := as.ListApplyStatus(ctx)
|
|
if err != nil {
|
|
return nil, s.logErr("ListApplyStatus", err)
|
|
}
|
|
out := make([]*pb.ApplyStatus, 0, len(statuses))
|
|
for _, status := range statuses {
|
|
out = append(out, applyStatusProto(status))
|
|
}
|
|
return &pb.ListApplyStatusResponse{Statuses: out}, nil
|
|
}
|
|
|
|
func (s *server) configSnapshots() (storecontract.ConfigSnapshotStore, error) {
|
|
if s.deps.ConfigSnapshots == nil {
|
|
return nil, errConfigSnapshotsUnavailable
|
|
}
|
|
return s.deps.ConfigSnapshots, nil
|
|
}
|
|
|
|
func (s *server) PutConfigSnapshot(ctx context.Context, r *pb.PutConfigSnapshotRequest) (*pb.PutConfigSnapshotResponse, error) {
|
|
cs, err := s.configSnapshots()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := cs.PutConfigSnapshot(ctx, configSnapshotValue(r.Snapshot)); err != nil {
|
|
return nil, s.logErr("PutConfigSnapshot", err)
|
|
}
|
|
return &pb.PutConfigSnapshotResponse{}, nil
|
|
}
|
|
|
|
func (s *server) GetConfigSnapshot(ctx context.Context, _ *pb.GetConfigSnapshotRequest) (*pb.GetConfigSnapshotResponse, error) {
|
|
cs, err := s.configSnapshots()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
snapshot, found, err := cs.ConfigSnapshot(ctx)
|
|
if err != nil {
|
|
return nil, s.logErr("GetConfigSnapshot", err)
|
|
}
|
|
if !found {
|
|
return &pb.GetConfigSnapshotResponse{}, nil
|
|
}
|
|
return &pb.GetConfigSnapshotResponse{Snapshot: configSnapshotProto(snapshot), Found: true}, nil
|
|
}
|
|
|
|
func (s *server) presence() (storecontract.PresenceStore, error) {
|
|
if s.deps.Presence == nil {
|
|
return nil, errPresenceUnavailable
|
|
}
|
|
return s.deps.Presence, nil
|
|
}
|
|
|
|
func (s *server) PutPresence(ctx context.Context, r *pb.PutPresenceRequest) (*pb.PutPresenceResponse, error) {
|
|
ps, err := s.presence()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
record := presenceValue(r.Presence)
|
|
if strings.HasPrefix(access.ActorFromContext(ctx), "task/") {
|
|
// A worker's clock cannot expire other services' retained records.
|
|
record.ReportedAt = time.Now().UTC()
|
|
if record.StartedAt.IsZero() || record.StartedAt.After(record.ReportedAt) {
|
|
record.StartedAt = record.ReportedAt
|
|
}
|
|
}
|
|
if err := ps.PutPresence(ctx, record); err != nil {
|
|
return nil, s.logErr("PutPresence", err)
|
|
}
|
|
return &pb.PutPresenceResponse{}, nil
|
|
}
|
|
|
|
func (s *server) ListPresence(ctx context.Context, _ *pb.ListPresenceRequest) (*pb.ListPresenceResponse, error) {
|
|
ps, err := s.presence()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
presences, err := ps.ListPresence(ctx)
|
|
if err != nil {
|
|
return nil, s.logErr("ListPresence", err)
|
|
}
|
|
out := make([]*pb.Presence, 0, len(presences))
|
|
for _, presence := range presences {
|
|
out = append(out, presenceProto(presence))
|
|
}
|
|
return &pb.ListPresenceResponse{Presences: out}, nil
|
|
}
|
|
|
|
func (s *server) RecordCaptureRefusal(ctx context.Context, r *pb.RecordCaptureRefusalRequest) (*pb.RecordCaptureRefusalResponse, error) {
|
|
if s.deps.Refusals == nil {
|
|
return nil, errRefusalsUnavailable
|
|
}
|
|
if err := s.deps.Refusals.RecordCaptureRefusal(ctx, r.Source, r.Addr, timeValue(r.RefusedAt)); err != nil {
|
|
return nil, s.logErr("RecordCaptureRefusal", err)
|
|
}
|
|
return &pb.RecordCaptureRefusalResponse{}, nil
|
|
}
|
|
|
|
func (s *server) ListCaptureRefusals(ctx context.Context, r *pb.ListCaptureRefusalsRequest) (*pb.ListCaptureRefusalsResponse, error) {
|
|
if s.deps.Refusals == nil {
|
|
return nil, errRefusalsUnavailable
|
|
}
|
|
sources, err := s.deps.Refusals.CaptureRefusals(ctx, timeValue(r.Since))
|
|
if err != nil {
|
|
return nil, s.logErr("ListCaptureRefusals", err)
|
|
}
|
|
out := make([]*pb.CaptureRefusals, 0, len(sources))
|
|
for _, c := range sources {
|
|
out = append(out, &pb.CaptureRefusals{Source: c.Source, Refused: c.Refused, Accepted: c.Accepted, Addrs: c.Addrs})
|
|
}
|
|
return &pb.ListCaptureRefusalsResponse{Sources: out}, nil
|
|
}
|
|
|
|
func (s *server) channelStatuses() (storecontract.ChannelStatusStore, error) {
|
|
if s.deps.ChannelStatus == nil {
|
|
return nil, errChannelStatusUnavailable
|
|
}
|
|
return s.deps.ChannelStatus, nil
|
|
}
|
|
|
|
func (s *server) PutChannelStatus(ctx context.Context, r *pb.PutChannelStatusRequest) (*pb.PutChannelStatusResponse, error) {
|
|
cs, err := s.channelStatuses()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := cs.PutChannelStatus(ctx, channelStatusesValue(r.Channels)); err != nil {
|
|
return nil, s.logErr("PutChannelStatus", err)
|
|
}
|
|
return &pb.PutChannelStatusResponse{}, nil
|
|
}
|
|
|
|
func (s *server) ListChannelStatus(ctx context.Context, _ *pb.ListChannelStatusRequest) (*pb.ListChannelStatusResponse, error) {
|
|
cs, err := s.channelStatuses()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
channels, err := cs.ChannelStatus(ctx)
|
|
if err != nil {
|
|
return nil, s.logErr("ListChannelStatus", err)
|
|
}
|
|
return &pb.ListChannelStatusResponse{Channels: channelStatusesProto(channels)}, nil
|
|
}
|
|
|
|
func (s *server) InsertCapture(ctx context.Context, r *pb.InsertCaptureRequest) (*pb.InsertCaptureResponse, error) {
|
|
cs, err := s.capture()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
id, err := cs.InsertCapture(ctx, capturedEventValue(r.Capture), timeSeconds(r.RetentionSeconds), int(r.MaxEvents))
|
|
if err != nil {
|
|
return nil, s.logErr("InsertCapture", err)
|
|
}
|
|
return &pb.InsertCaptureResponse{Id: id}, nil
|
|
}
|
|
|
|
// StreamCaptures streams one capture per message: a batch of large capture
|
|
// bodies in one unary response can exceed gRPC's 4MiB message cap
|
|
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() (storecontract.MappingStore, error) {
|
|
if s.deps.Mappings == nil {
|
|
return nil, errMappingUnavailable
|
|
}
|
|
return s.deps.Mappings, nil
|
|
}
|
|
|
|
func (s *server) InsertMapping(ctx context.Context, r *pb.InsertMappingRequest) (*pb.InsertMappingResponse, error) {
|
|
ms, err := s.mapping()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
value := mappingValue(r.Mapping)
|
|
if err := value.Validate(); err != nil {
|
|
return nil, validationFailure(err)
|
|
}
|
|
id, err := ms.InsertMapping(ctx, value)
|
|
if err != nil {
|
|
return nil, s.logErr("InsertMapping", err)
|
|
}
|
|
return &pb.InsertMappingResponse{Id: id}, nil
|
|
}
|
|
|
|
func (s *server) GetMapping(ctx context.Context, r *pb.GetMappingRequest) (*pb.GetMappingResponse, error) {
|
|
ms, err := s.mapping()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
m, err := ms.GetMapping(ctx, r.Id)
|
|
if err != nil {
|
|
return nil, s.logErr("GetMapping", err)
|
|
}
|
|
return &pb.GetMappingResponse{Mapping: mappingProtoPtr(m), Found: m != nil}, nil
|
|
}
|
|
|
|
func (s *server) ListMappings(ctx context.Context, _ *pb.ListMappingsRequest) (*pb.ListMappingsResponse, error) {
|
|
ms, err := s.mapping()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
mappings, err := ms.ListMappings(ctx)
|
|
if err != nil {
|
|
return nil, s.logErr("ListMappings", err)
|
|
}
|
|
return &pb.ListMappingsResponse{Mappings: mapValues(mappings, mappingProto)}, nil
|
|
}
|
|
|
|
func (s *server) UpdateMapping(ctx context.Context, r *pb.UpdateMappingRequest) (*pb.UpdateMappingResponse, error) {
|
|
ms, err := s.mapping()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
value := mappingValue(r.Mapping)
|
|
if err := value.Validate(); err != nil {
|
|
return nil, validationFailure(err)
|
|
}
|
|
if err := ms.UpdateMapping(ctx, value); err != nil {
|
|
return nil, s.logErr("UpdateMapping", err)
|
|
}
|
|
return &pb.UpdateMappingResponse{}, nil
|
|
}
|
|
|
|
func (s *server) DeleteMapping(ctx context.Context, r *pb.DeleteMappingRequest) (*pb.DeleteMappingResponse, error) {
|
|
ms, err := s.mapping()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := ms.DeleteMapping(ctx, r.Id); err != nil {
|
|
return nil, s.logErr("DeleteMapping", err)
|
|
}
|
|
return &pb.DeleteMappingResponse{}, nil
|
|
}
|
|
|
|
func (s *server) RecordMappingMatch(ctx context.Context, r *pb.RecordMappingMatchRequest) (*pb.RecordMappingMatchResponse, error) {
|
|
if s.deps.MappingMatches == nil {
|
|
return nil, status.Error(codes.Unavailable, "mapping match recorder unavailable")
|
|
}
|
|
if err := s.deps.MappingMatches.RecordMappingMatch(ctx, r.MappingId, r.CaptureId); err != nil {
|
|
return nil, s.logErr("RecordMappingMatch", err)
|
|
}
|
|
return &pb.RecordMappingMatchResponse{}, nil
|
|
}
|
|
|
|
// Binding
|
|
|
|
func (s *server) binding() (storecontract.BindingStore, error) {
|
|
if s.deps.Bindings == nil {
|
|
return nil, errBindingUnavailable
|
|
}
|
|
return s.deps.Bindings, nil
|
|
}
|
|
|
|
func (s *server) InsertBinding(ctx context.Context, r *pb.InsertBindingRequest) (*pb.InsertBindingResponse, error) {
|
|
bs, err := s.binding()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
value := bindingValue(r.Binding)
|
|
if err := value.Validate(); err != nil {
|
|
return nil, validationFailure(err)
|
|
}
|
|
id, err := bs.InsertBinding(ctx, value)
|
|
if err != nil {
|
|
return nil, s.logErr("InsertBinding", err)
|
|
}
|
|
return &pb.InsertBindingResponse{Id: id}, nil
|
|
}
|
|
|
|
func (s *server) GetBinding(ctx context.Context, r *pb.GetBindingRequest) (*pb.GetBindingResponse, error) {
|
|
bs, err := s.binding()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
b, err := bs.GetBinding(ctx, r.Id)
|
|
if err != nil {
|
|
return nil, s.logErr("GetBinding", err)
|
|
}
|
|
return &pb.GetBindingResponse{Binding: bindingProtoPtr(b), Found: b != nil}, nil
|
|
}
|
|
|
|
func (s *server) ListBindings(ctx context.Context, _ *pb.ListBindingsRequest) (*pb.ListBindingsResponse, error) {
|
|
bs, err := s.binding()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
bindings, err := bs.ListBindings(ctx)
|
|
if err != nil {
|
|
return nil, s.logErr("ListBindings", err)
|
|
}
|
|
return &pb.ListBindingsResponse{Bindings: mapValues(bindings, bindingProto)}, nil
|
|
}
|
|
|
|
func (s *server) UpdateBinding(ctx context.Context, r *pb.UpdateBindingRequest) (*pb.UpdateBindingResponse, error) {
|
|
bs, err := s.binding()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
value := bindingValue(r.Binding)
|
|
if err := value.Validate(); err != nil {
|
|
return nil, validationFailure(err)
|
|
}
|
|
if err := bs.UpdateBinding(ctx, value); err != nil {
|
|
return nil, s.logErr("UpdateBinding", err)
|
|
}
|
|
return &pb.UpdateBindingResponse{}, nil
|
|
}
|
|
|
|
func (s *server) DeleteBinding(ctx context.Context, r *pb.DeleteBindingRequest) (*pb.DeleteBindingResponse, error) {
|
|
bs, err := s.binding()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := bs.DeleteBinding(ctx, r.Id); err != nil {
|
|
return nil, s.logErr("DeleteBinding", err)
|
|
}
|
|
return &pb.DeleteBindingResponse{}, nil
|
|
}
|
|
|
|
func (s *server) PauseBinding(ctx context.Context, r *pb.PauseBindingRequest) (*pb.PauseBindingResponse, error) {
|
|
bs, err := s.binding()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := bs.PauseBinding(ctx, r.Id); err != nil {
|
|
return nil, s.logErr("PauseBinding", err)
|
|
}
|
|
return &pb.PauseBindingResponse{}, nil
|
|
}
|
|
|
|
func (s *server) ResumeBinding(ctx context.Context, r *pb.ResumeBindingRequest) (*pb.ResumeBindingResponse, error) {
|
|
bs, err := s.binding()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := bs.ResumeBinding(ctx, r.Id); err != nil {
|
|
return nil, s.logErr("ResumeBinding", err)
|
|
}
|
|
return &pb.ResumeBindingResponse{}, nil
|
|
}
|
|
|
|
func (s *server) ApproveBinding(ctx context.Context, r *pb.ApproveBindingRequest) (*pb.ApproveBindingResponse, error) {
|
|
bs, err := s.binding()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := bs.ApproveBinding(ctx, r.Id); err != nil {
|
|
return nil, s.logErr("ApproveBinding", err)
|
|
}
|
|
return &pb.ApproveBindingResponse{}, nil
|
|
}
|
|
|
|
// Source
|
|
|
|
func (s *server) sources() (storecontract.SourceStore, error) {
|
|
if s.deps.Sources == nil {
|
|
return nil, errSourceUnavailable
|
|
}
|
|
return s.deps.Sources, nil
|
|
}
|
|
|
|
func (s *server) InsertSource(ctx context.Context, r *pb.InsertSourceRequest) (*pb.InsertSourceResponse, error) {
|
|
ss, err := s.sources()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := ss.InsertSource(ctx, sourceValue(r.Source)); err != nil {
|
|
return nil, s.logErr("InsertSource", err)
|
|
}
|
|
return &pb.InsertSourceResponse{}, nil
|
|
}
|
|
|
|
func (s *server) GetSource(ctx context.Context, r *pb.GetSourceRequest) (*pb.GetSourceResponse, error) {
|
|
ss, err := s.sources()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
src, err := ss.GetSource(ctx, r.Path)
|
|
if err != nil {
|
|
return nil, s.logErr("GetSource", err)
|
|
}
|
|
if src == nil {
|
|
return &pb.GetSourceResponse{}, nil
|
|
}
|
|
return &pb.GetSourceResponse{Source: sourceProto(*src), Found: true}, nil
|
|
}
|
|
|
|
func (s *server) ListSources(ctx context.Context, _ *pb.ListSourcesRequest) (*pb.ListSourcesResponse, error) {
|
|
ss, err := s.sources()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
list, err := ss.ListSources(ctx)
|
|
if err != nil {
|
|
return nil, s.logErr("ListSources", err)
|
|
}
|
|
return &pb.ListSourcesResponse{Sources: mapValues(list, sourceProto)}, nil
|
|
}
|
|
|
|
func (s *server) SetSourceSigning(ctx context.Context, r *pb.SetSourceSigningRequest) (*pb.SetSourceSigningResponse, error) {
|
|
ss, err := s.sources()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := ss.SetSourceSigning(ctx, r.Path, source.Signing(r.From), source.Signing(r.To)); err != nil {
|
|
return nil, s.logErr("SetSourceSigning", err)
|
|
}
|
|
return &pb.SetSourceSigningResponse{}, nil
|
|
}
|
|
|
|
func (s *server) SetSourceSecret(ctx context.Context, r *pb.SetSourceSecretRequest) (*pb.SetSourceSecretResponse, error) {
|
|
ss, err := s.sources()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := ss.SetSourceSecret(ctx, r.Path, r.Secret); err != nil {
|
|
return nil, s.logErr("SetSourceSecret", err)
|
|
}
|
|
return &pb.SetSourceSecretResponse{}, nil
|
|
}
|
|
|
|
func (s *server) SetSourceName(ctx context.Context, r *pb.SetSourceNameRequest) (*pb.SetSourceNameResponse, error) {
|
|
ss, err := s.sources()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := ss.SetSourceName(ctx, r.Path, r.Name); err != nil {
|
|
return nil, s.logErr("SetSourceName", err)
|
|
}
|
|
return &pb.SetSourceNameResponse{}, nil
|
|
}
|
|
|
|
func (s *server) SetSourceDeliveryHeader(ctx context.Context, r *pb.SetSourceDeliveryHeaderRequest) (*pb.SetSourceDeliveryHeaderResponse, error) {
|
|
ss, err := s.sources()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := ss.SetSourceDeliveryHeader(ctx, r.Path, r.Header); err != nil {
|
|
return nil, s.logErr("SetSourceDeliveryHeader", err)
|
|
}
|
|
return &pb.SetSourceDeliveryHeaderResponse{}, nil
|
|
}
|
|
|
|
func (s *server) DeleteSource(ctx context.Context, r *pb.DeleteSourceRequest) (*pb.DeleteSourceResponse, error) {
|
|
ss, err := s.sources()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := ss.DeleteSource(ctx, r.Path); err != nil {
|
|
return nil, s.logErr("DeleteSource", err)
|
|
}
|
|
return &pb.DeleteSourceResponse{}, nil
|
|
}
|
|
|
|
// Dispatch
|
|
|
|
func (s *server) ArmedBindingsForSource(ctx context.Context, r *pb.ArmedBindingsForSourceRequest) (*pb.ArmedBindingsForSourceResponse, error) {
|
|
if s.deps.BindingDispatcher == nil {
|
|
return nil, errBindingDispatchUnavailable
|
|
}
|
|
bindings, err := s.deps.BindingDispatcher.ArmedBindingsForSource(ctx, r.Source)
|
|
if err != nil {
|
|
return nil, s.logErr("ArmedBindingsForSource", err)
|
|
}
|
|
return &pb.ArmedBindingsForSourceResponse{Bindings: mapValues(bindings, bindingProto)}, nil
|
|
}
|
|
|
|
func (s *server) RecordDispatch(ctx context.Context, r *pb.RecordDispatchRequest) (*pb.RecordDispatchResponse, error) {
|
|
if s.deps.BindingDispatcher == nil {
|
|
return nil, errBindingDispatchUnavailable
|
|
}
|
|
if err := s.deps.BindingDispatcher.RecordDispatch(ctx, r.BindingId, r.BindingVersion, r.CaptureId, r.TaskId, r.Reason); err != nil {
|
|
return nil, s.logErr("RecordDispatch", err)
|
|
}
|
|
return &pb.RecordDispatchResponse{}, nil
|
|
}
|
|
|
|
func (s *server) ListDispatches(ctx context.Context, r *pb.ListDispatchesRequest) (*pb.ListDispatchesResponse, error) {
|
|
bs, err := s.binding()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ledger, ok := bs.(storecontract.DispatchLedger)
|
|
if !ok {
|
|
return nil, errBindingDispatchUnavailable
|
|
}
|
|
dispatches, err := ledger.ListDispatches(ctx, storecontract.DispatchFilter{
|
|
BindingID: r.BindingId, CaptureID: r.CaptureId, TaskID: r.TaskId, Limit: int(r.Limit),
|
|
})
|
|
if err != nil {
|
|
return nil, s.logErr("ListDispatches", err)
|
|
}
|
|
return &pb.ListDispatchesResponse{Dispatches: mapValues(dispatches, func(d storecontract.Dispatch) *pb.Dispatch {
|
|
return &pb.Dispatch{
|
|
BindingId: d.BindingID, BindingVersion: d.BindingVersion, CaptureId: d.CaptureID,
|
|
TaskId: d.TaskID, Reason: d.Reason, DispatchedAt: timestamp(d.DispatchedAt),
|
|
}
|
|
})}, nil
|
|
}
|
|
|
|
// Playbook dispatch
|
|
|
|
func (s *server) RecordPlaybookDispatch(ctx context.Context, r *pb.RecordPlaybookDispatchRequest) (*pb.RecordPlaybookDispatchResponse, error) {
|
|
if s.deps.PlaybookDispatcher == nil {
|
|
return nil, errPlaybookDispatcherUnavailable
|
|
}
|
|
if err := s.deps.PlaybookDispatcher.RecordPlaybookDispatch(ctx, r.PlaybookId, r.PlaybookVersion, r.EventId, r.ActionId); err != nil {
|
|
return nil, s.logErr("RecordPlaybookDispatch", err)
|
|
}
|
|
return &pb.RecordPlaybookDispatchResponse{}, nil
|
|
}
|
|
|
|
func (s *server) DeletePlaybookDispatches(ctx context.Context, r *pb.DeletePlaybookDispatchesRequest) (*pb.DeletePlaybookDispatchesResponse, error) {
|
|
if s.deps.PlaybookDispatcher == nil {
|
|
return nil, errPlaybookDispatcherUnavailable
|
|
}
|
|
if err := s.deps.PlaybookDispatcher.DeletePlaybookDispatches(ctx, r.PlaybookId); err != nil {
|
|
return nil, s.logErr("DeletePlaybookDispatches", err)
|
|
}
|
|
return &pb.DeletePlaybookDispatchesResponse{}, nil
|
|
}
|
|
|
|
// StreamUndispatchedCaptures streams for the same reason as StreamCaptures.
|
|
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.Bindings, 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) {
|
|
if s.deps.BindingTaskCreator == nil {
|
|
return nil, errBindingTaskCreatorUnavailable
|
|
}
|
|
inputs, err := task.DecodeInputs(r.InputsJson)
|
|
if err != nil {
|
|
return nil, status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
t, err := s.deps.BindingTaskCreator.EnqueueBindingTask(ctx, r.Owner, r.Repo, r.Title, r.Body, r.Workflow, r.Identity, r.BindingId, int(r.BindingVersion), r.CaptureId, inputs)
|
|
if err != nil {
|
|
return nil, s.logErr("EnqueueBindingTask", err)
|
|
}
|
|
return &pb.EnqueueBindingTaskResponse{Task: taskProto(t)}, nil
|
|
}
|
|
|
|
// WorkflowCaller: a workflow.call step starts its callee and reads it back
|
|
// while waiting. The grant already named the
|
|
// caller; the store's own row checks are what make both calls answer only
|
|
// for this caller's own callees.
|
|
|
|
func (s *server) EnqueueCallTask(ctx context.Context, r *pb.EnqueueCallTaskRequest) (*pb.EnqueueCallTaskResponse, error) {
|
|
if s.deps.WorkflowCalls == nil {
|
|
return nil, errWorkflowCallerUnavailable
|
|
}
|
|
if r.CallerTaskId <= 0 {
|
|
return nil, status.Error(codes.InvalidArgument, "caller task id is required")
|
|
}
|
|
// A call is identified by its key: without one the store would have to
|
|
// guess, and two calls of one caller would collide or duplicate.
|
|
if r.CallKey == "" {
|
|
return nil, status.Error(codes.InvalidArgument, "call key is required")
|
|
}
|
|
inputs, err := task.DecodeInputs(r.InputsJson)
|
|
if err != nil {
|
|
return nil, status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
t, err := s.deps.WorkflowCalls.StartCall(ctx, r.CallerTaskId, r.CallKey, r.Workflow, inputs)
|
|
if err != nil {
|
|
return nil, s.logErr("EnqueueCallTask", err)
|
|
}
|
|
return &pb.EnqueueCallTaskResponse{Task: taskProto(t), Accepted: true}, nil
|
|
}
|
|
|
|
func (s *server) WorkflowCallStatus(ctx context.Context, r *pb.WorkflowCallStatusRequest) (*pb.WorkflowCallStatusResponse, error) {
|
|
if s.deps.WorkflowCalls == nil {
|
|
return nil, errWorkflowCallerUnavailable
|
|
}
|
|
status, detail, outputs, err := s.deps.WorkflowCalls.CallStatus(ctx, r.CallerTaskId, r.CallTaskId)
|
|
if err != nil {
|
|
return nil, s.logErr("WorkflowCallStatus", err)
|
|
}
|
|
return &pb.WorkflowCallStatusResponse{Status: status, Detail: detail, OutputsJson: outputsJSON(outputs)}, nil
|
|
}
|
|
|
|
// Task log
|
|
|
|
func (s *server) taskLogs() (storecontract.TaskLogStore, error) {
|
|
if s.deps.TaskLogs == nil {
|
|
return nil, errTaskLogsUnavailable
|
|
}
|
|
return s.deps.TaskLogs, nil
|
|
}
|
|
|
|
func (s *server) ReadTaskLog(ctx context.Context, r *pb.ReadTaskLogRequest) (*pb.ReadTaskLogResponse, error) {
|
|
logs, err := s.taskLogs()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
page, err := logs.TaskLog(ctx, r.TaskId, int(r.Attempt), taskLogQueryValue(r))
|
|
if err != nil {
|
|
// A store that cannot read its own state directory keeps its own
|
|
// identity: this is unavailability, not a missing log, and a caller
|
|
// has to be able to tell them apart.
|
|
if errors.Is(err, logging.ErrTaskLogsUnavailable) {
|
|
return nil, errTaskLogsUnavailable
|
|
}
|
|
return nil, s.logErr("ReadTaskLog", err)
|
|
}
|
|
if !page.Found {
|
|
return &pb.ReadTaskLogResponse{Attempt: r.Attempt}, nil
|
|
}
|
|
return &pb.ReadTaskLogResponse{
|
|
Entries: mapValues(page.Entries, taskLogEntryProto),
|
|
Truncated: page.Truncated,
|
|
MoreAvailable: page.MoreAvailable,
|
|
Cursor: page.Cursor,
|
|
Attempt: r.Attempt,
|
|
Found: true,
|
|
Components: page.Components,
|
|
File: page.File,
|
|
}, nil
|
|
}
|
|
|
|
// StreamTaskLogContent sends one attempt's log verbatim, one chunk per
|
|
// message, for a download. A single reply reports found=false with no chunks:
|
|
// the attempt has no log file, which is a normal state rather than a failure.
|
|
func (s *server) StreamTaskLogContent(r *pb.StreamTaskLogContentRequest, stream pb.StateStoreService_StreamTaskLogContentServer) error {
|
|
logs, err := s.taskLogs()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// The chunking the client sees is owned by the reader that writes into
|
|
// this buffer, so the wire never holds a whole log to re-slice it.
|
|
buf := &chunkWriter{stream: stream, attempt: r.Attempt}
|
|
found, err := logs.TaskLogContent(stream.Context(), r.TaskId, int(r.Attempt), buf)
|
|
if err != nil {
|
|
if errors.Is(err, logging.ErrTaskLogsUnavailable) {
|
|
return errTaskLogsUnavailable
|
|
}
|
|
return s.logErr("StreamTaskLogContent", err)
|
|
}
|
|
if err := buf.flush(); err != nil {
|
|
return err
|
|
}
|
|
// A found log with no bytes still reports found: an attempt whose file is
|
|
// empty did produce a log, and found is what tells the download it may
|
|
// write an empty file rather than answer 404.
|
|
if found && buf.sent {
|
|
return nil
|
|
}
|
|
return stream.Send(&pb.StreamTaskLogContentResponse{Attempt: r.Attempt, Found: found})
|
|
}
|
|
|
|
// chunkWriter packs everything a log reader writes into stream-sized messages
|
|
// on its way through. It exists so the read can be one io.CopyBuffer of the
|
|
// file into this writer: the reader keeps its own chunk size, and the bytes
|
|
// are never all held at once.
|
|
type chunkWriter struct {
|
|
stream pb.StateStoreService_StreamTaskLogContentServer
|
|
attempt int64
|
|
pending []byte
|
|
// sent records whether any chunk reached the client, which is how the
|
|
// caller tells "the file was empty" from "the file was read".
|
|
sent bool
|
|
}
|
|
|
|
func (w *chunkWriter) Write(p []byte) (int, error) {
|
|
w.pending = append(w.pending, p...)
|
|
for len(w.pending) >= taskLogChunkBytes {
|
|
if err := w.emit(w.pending[:taskLogChunkBytes]); err != nil {
|
|
return 0, err
|
|
}
|
|
w.pending = w.pending[taskLogChunkBytes:]
|
|
}
|
|
return len(p), nil
|
|
}
|
|
|
|
func (w *chunkWriter) emit(chunk []byte) error {
|
|
w.sent = true
|
|
// The slice is copied into the message: the reader's buffer is reused
|
|
// across writes and must not be aliased by a message in flight.
|
|
return w.stream.Send(&pb.StreamTaskLogContentResponse{
|
|
Chunk: bytes.Clone(chunk),
|
|
Attempt: w.attempt,
|
|
Found: true,
|
|
})
|
|
}
|
|
|
|
func (w *chunkWriter) flush() error {
|
|
if len(w.pending) == 0 {
|
|
return nil
|
|
}
|
|
chunk := w.pending
|
|
w.pending = nil
|
|
return w.emit(chunk)
|
|
}
|
|
|
|
func mappingProtoPtr(m *mapping.Mapping) *pb.Mapping {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
return mappingProto(*m)
|
|
}
|
|
|
|
func bindingProtoPtr(b *binding.Binding) *pb.Binding {
|
|
if b == nil {
|
|
return nil
|
|
}
|
|
return bindingProto(*b)
|
|
}
|