Files
archie/internal/infrastructure/staterpc/client.go
T
sam e16ba86b30 feat(harness): ingest OAuth storage and recover workflow write handling
Recover the OAuth storage slice from f6079e9d and the missing workflow persistence error handling from f07c314e, adapted to the current step contract. Require encryption for OAuth token storage and verify RPC round trips and task-grant denial.
2026-09-27 13:09:41 +10:00

747 lines
26 KiB
Go

package staterpc
import (
"context"
"errors"
"io"
"time"
"google.golang.org/grpc"
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/binding"
"github.com/samcharles93/archie-core/internal/domain/harnesssecret"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/mapping"
"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/workflow/task"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/logging"
)
// Client is the single remote adapter wrapping one StateStoreServiceClient,
// asserted against whichever narrow Go interfaces its caller needs -- exactly
// as gatewayrpc.Client asserts both messaging.ChatContract and
// messaging.SessionStore. See docs/prds/state-store-contract.md §2.
type Client struct {
client pb.StateStoreServiceClient
controlPlane controlpb.ControlPlaneServiceClient
}
// NewClient wraps conn's generated client. Close is a no-op: the store
// service owns its own DB lifecycle (§11).
func NewClient(conn grpc.ClientConnInterface) *Client {
return &Client{client: pb.NewStateStoreServiceClient(conn), controlPlane: controlpb.NewControlPlaneServiceClient(conn)}
}
// ControlPlane returns the generic control-plane RPC client on the same authenticated connection.
func (c *Client) ControlPlane() controlpb.ControlPlaneServiceClient { return c.controlPlane }
// Close is a no-op; the remote store service owns its own DB lifecycle.
func (c *Client) Close() error { return nil }
var (
_ storecontract.HarnessSecretStore = (*Client)(nil)
_ task.Store = (*Client)(nil)
_ task.Caller = (*Client)(nil)
_ storecontract.TaskStore = (*Client)(nil)
_ storecontract.TaskLogStore = (*Client)(nil)
_ storecontract.CaptureStore = (*Client)(nil)
_ storecontract.MappingStore = (*Client)(nil)
_ storecontract.BindingStore = (*Client)(nil)
_ storecontract.SourceStore = (*Client)(nil)
_ storecontract.BindingDispatcher = (*Client)(nil)
_ storecontract.MappingMatchRecorder = (*Client)(nil)
_ storecontract.BindingTaskCreator = (*Client)(nil)
_ storecontract.PlaybookDispatcher = (*Client)(nil)
_ storecontract.ConfigSnapshotStore = (*Client)(nil)
_ storecontract.ChannelStatusStore = (*Client)(nil)
_ storecontract.ApplyStatusStore = (*Client)(nil)
_ storecontract.ExecutionCanceller = (*Client)(nil)
_ identity.Repository = (*Client)(nil)
_ storepkg.Manager = (*Client)(nil)
)
// Lifecycle
func (c *Client) EnqueueIssue(ctx context.Context, owner, repo string, number int, title, body, labels, identity string) (bool, error) {
r, err := c.client.EnqueueIssue(ctx, &pb.EnqueueIssueRequest{Owner: owner, Repo: repo, Number: int64(number), Title: title, Body: body, Labels: labels, Identity: identity})
if err != nil {
return false, unmapError(err)
}
return r.Inserted, nil
}
func (c *Client) EnqueueChatTask(ctx context.Context, owner, repo, title, body, wf, identity string) (*task.Task, error) {
r, err := c.client.EnqueueChatTask(ctx, &pb.EnqueueChatTaskRequest{Owner: owner, Repo: repo, Title: title, Body: body, Workflow: wf, Identity: identity})
if err != nil {
return nil, unmapError(err)
}
return taskValue(r.Task), nil
}
func (c *Client) ClaimNext(ctx context.Context) (*task.Task, error) {
r, err := c.client.ClaimNext(ctx, &pb.ClaimNextRequest{})
if err != nil {
return nil, unmapError(err)
}
if !r.Found {
return nil, nil
}
return taskValue(r.Task), nil
}
func (c *Client) ClaimByIssue(ctx context.Context, owner, repo string, number int) (*task.Task, error) {
r, err := c.client.ClaimByIssue(ctx, &pb.ClaimByIssueRequest{Owner: owner, Repo: repo, Number: int64(number)})
if err != nil {
return nil, unmapError(err)
}
if !r.Found {
return nil, nil
}
return taskValue(r.Task), nil
}
func (c *Client) Transition(ctx context.Context, taskID int64, from, to, detail string) error {
_, err := c.client.Transition(ctx, &pb.TransitionRequest{TaskId: taskID, From: from, To: to, Detail: detail})
return unmapError(err)
}
// StartStep and FinishStep record the run's step executions
// (docs/prds/execution-tree-state-machine.md) under the run credential, which
// the State Store's grant interceptor scopes to the execution the requests
// name. Each returns the transition's persisted event for the caller's
// post-commit publish.
func (c *Client) StartStep(ctx context.Context, s task.StepStart) (int64, events.Event, error) {
r, err := c.client.StartStep(ctx, &pb.StartStepRequest{
ExecutionId: s.ExecutionID, Attempt: int64(s.Attempt),
ParentId: s.ParentID, Kind: s.Kind, Name: s.Name,
CalledExecutionId: s.CalledExecutionID,
})
if err != nil {
return 0, events.Event{}, unmapError(err)
}
event := events.Event{}
if r.Event != nil {
event = eventValue(r.Event)
}
return r.StepId, event, nil
}
// CancelExecution is the one cancel path (docs/prds/execution-tree-state-machine.md):
// the State Store records the cancellation -- every non-terminal step of the
// current attempt plus the execution's own move -- and returns the steps it
// cancelled; the caller cancels the run's in-memory context afterwards.
func (c *Client) CancelExecution(ctx context.Context, taskID int64, reason, to string) ([]int64, error) {
r, err := c.client.CancelExecution(ctx, &pb.CancelExecutionRequest{TaskId: taskID, Reason: reason, To: to})
if err != nil {
return nil, unmapError(err)
}
return r.CancelledStepIds, nil
}
func (c *Client) FinishStep(ctx context.Context, s task.StepFinish) (events.Event, error) {
r, err := c.client.FinishStep(ctx, &pb.FinishStepRequest{
ExecutionId: s.ExecutionID, StepId: s.StepID,
From: string(s.From), To: string(s.To), Detail: s.Detail, TokensUsed: s.TokensUsed,
})
if err != nil {
return events.Event{}, unmapError(err)
}
event := events.Event{}
if r.Event != nil {
event = eventValue(r.Event)
}
return event, nil
}
func (c *Client) ListSteps(ctx context.Context, executionID int64, attempt int) ([]task.StepExecution, error) {
r, err := c.client.ListSteps(ctx, &pb.ListStepsRequest{ExecutionId: executionID, Attempt: int64(attempt)})
if err != nil {
return nil, unmapError(err)
}
steps := make([]task.StepExecution, len(r.Steps))
for i, s := range r.Steps {
steps[i] = stepExecutionValue(s)
}
return steps, nil
}
func (c *Client) Update(ctx context.Context, t *task.Task) error {
_, err := c.client.Update(ctx, &pb.UpdateRequest{Task: taskProto(t)})
return unmapError(err)
}
func (c *Client) Requeue(ctx context.Context, taskID int64, fromStatus, wf string) error {
_, err := c.client.Requeue(ctx, &pb.RequeueRequest{TaskId: taskID, FromStatus: fromStatus, Workflow: wf})
return unmapError(err)
}
func (c *Client) ParkTask(ctx context.Context, taskID int64, from, detail, class string) error {
_, err := c.client.ParkTask(ctx, &pb.ParkTaskRequest{TaskId: taskID, From: from, Detail: detail, Class: class})
return unmapError(err)
}
func (c *Client) RecoverStale(ctx context.Context) (int64, error) {
r, err := c.client.RecoverStale(ctx, &pb.RecoverStaleRequest{})
if err != nil {
return 0, unmapError(err)
}
return r.Count, nil
}
// Archive / Retry
func (c *Client) ArchiveTask(ctx context.Context, taskID int64, fromStatus string, audit events.Event) (int64, error) {
r, err := c.client.ArchiveTask(ctx, &pb.ArchiveTaskRequest{TaskId: taskID, FromStatus: fromStatus, Audit: eventProto(audit)})
if err != nil {
return 0, unmapError(err)
}
return r.EventId, nil
}
func (c *Client) RetryTask(ctx context.Context, taskID int64, fromStatus, wf string) error {
_, err := c.client.RetryTask(ctx, &pb.RetryTaskRequest{TaskId: taskID, FromStatus: fromStatus, Workflow: wf})
return unmapError(err)
}
func (c *Client) BeginRemediation(ctx context.Context, taskID int64, payload string) error {
_, err := c.client.BeginRemediation(ctx, &pb.BeginRemediationRequest{TaskId: taskID, Payload: payload})
return unmapError(err)
}
func (c *Client) UpdateReviewPayload(ctx context.Context, taskID int64, payload string) error {
_, err := c.client.UpdateReviewPayload(ctx, &pb.UpdateReviewPayloadRequest{TaskId: taskID, Payload: payload})
return unmapError(err)
}
func (c *Client) SetReviewCursors(ctx context.Context, taskID, reviewCursor, commentCursor int64) error {
_, err := c.client.SetReviewCursors(ctx, &pb.SetReviewCursorsRequest{TaskId: taskID, ReviewCursor: reviewCursor, CommentCursor: commentCursor})
return unmapError(err)
}
// Queries
func (c *Client) TaskByIssue(ctx context.Context, owner, repo string, number int) (*task.Task, error) {
r, err := c.client.TaskByIssue(ctx, &pb.TaskByIssueRequest{Owner: owner, Repo: repo, Number: int64(number)})
if err != nil {
return nil, unmapError(err)
}
if !r.Found {
return nil, nil
}
return taskValue(r.Task), nil
}
func (c *Client) OpenTaskByPR(ctx context.Context, owner, repo string, number int) (*task.Task, error) {
r, err := c.client.OpenTaskByPR(ctx, &pb.OpenTaskByPRRequest{Owner: owner, Repo: repo, Number: int64(number)})
if err != nil {
return nil, unmapError(err)
}
if !r.Found {
return nil, nil
}
return taskValue(r.Task), nil
}
func (c *Client) TaskByID(ctx context.Context, taskID int64) (*task.Task, error) {
r, err := c.client.TaskByID(ctx, &pb.TaskByIDRequest{TaskId: taskID})
if err != nil {
return nil, unmapError(err)
}
if !r.Found {
return nil, nil
}
return taskValue(r.Task), nil
}
func (c *Client) OpenPRs(ctx context.Context) ([]task.Task, error) {
r, err := c.client.OpenPRs(ctx, &pb.OpenPRsRequest{})
if err != nil {
return nil, unmapError(err)
}
return derefTasks(r.Tasks), nil
}
func (c *Client) ClearTerminalTasks(ctx context.Context) (int64, error) {
r, err := c.client.ClearTerminalTasks(ctx, &pb.ClearTerminalTasksRequest{})
if err != nil {
return 0, unmapError(err)
}
return r.Count, nil
}
func (c *Client) Tasks(ctx context.Context, limit int) ([]task.Task, error) {
r, err := c.client.Tasks(ctx, &pb.TasksRequest{Limit: int64(limit)})
if err != nil {
return nil, unmapError(err)
}
return derefTasks(r.Tasks), nil
}
func (c *Client) StatusCounts(ctx context.Context) (map[string]int, error) {
r, err := c.client.StatusCounts(ctx, &pb.StatusCountsRequest{})
if err != nil {
return nil, unmapError(err)
}
out := make(map[string]int, len(r.Counts))
for k, v := range r.Counts {
out[k] = int(v)
}
return out, nil
}
// Events
func (c *Client) InsertEvent(ctx context.Context, e events.Event) (int64, error) {
r, err := c.client.InsertEvent(ctx, &pb.InsertEventRequest{Event: eventProto(e)})
if err != nil {
return 0, unmapError(err)
}
return r.Id, nil
}
func (c *Client) EventsSince(ctx context.Context, cursor string, limit int) ([]events.Event, error) {
r, err := c.client.EventsSince(ctx, &pb.EventsSinceRequest{SinceId: cursor, Limit: int64(limit)})
if err != nil {
return nil, unmapError(err)
}
return mapValues(r.Events, eventValue), nil
}
func (c *Client) TaskEvents(ctx context.Context, taskID int64) ([]events.Event, error) {
r, err := c.client.TaskEvents(ctx, &pb.TaskEventsRequest{TaskId: taskID})
if err != nil {
return nil, unmapError(err)
}
return mapValues(r.Events, eventValue), nil
}
func (c *Client) WorkflowStats(ctx context.Context) ([]storecontract.WorkflowStat, error) {
r, err := c.client.WorkflowStats(ctx, &pb.WorkflowStatsRequest{})
if err != nil {
return nil, unmapError(err)
}
return mapValues(r.Stats, workflowStatValue), nil
}
func (c *Client) StageStats(ctx context.Context) ([]storecontract.StageStat, error) {
r, err := c.client.StageStats(ctx, &pb.StageStatsRequest{})
if err != nil {
return nil, unmapError(err)
}
return mapValues(r.Stats, stageStatValue), nil
}
func (c *Client) TokensByDay(ctx context.Context, days int) ([]storecontract.DayTokens, error) {
r, err := c.client.TokensByDay(ctx, &pb.TokensByDayRequest{Days: int64(days)})
if err != nil {
return nil, unmapError(err)
}
return mapValues(r.Tokens, dayTokensValue), nil
}
// Capture
func (c *Client) InsertCapture(ctx context.Context, ce storecontract.CapturedEvent, retention time.Duration, maxEvents int) (string, error) {
r, err := c.client.InsertCapture(ctx, &pb.InsertCaptureRequest{Capture: capturedEventProto(ce), RetentionSeconds: int64(retention.Seconds()), MaxEvents: int64(maxEvents)})
if err != nil {
return "", unmapError(err)
}
return r.Id, nil
}
// PutConfigSnapshot publishes the dashboard's configuration projection. The
// server admits it on the administrative token only; a task-scoped grant
// cannot reach it (see TaskGrants).
func (c *Client) PutConfigSnapshot(ctx context.Context, snapshot storecontract.ConfigSnapshot) error {
_, err := c.client.PutConfigSnapshot(ctx, &pb.PutConfigSnapshotRequest{Snapshot: configSnapshotProto(snapshot)})
if err != nil {
return unmapError(err)
}
return nil
}
// ConfigSnapshot reads the published projection. found is false, with a nil
// error, before a daemon has published one.
func (c *Client) ConfigSnapshot(ctx context.Context) (storecontract.ConfigSnapshot, bool, error) {
reply, err := c.client.GetConfigSnapshot(ctx, &pb.GetConfigSnapshotRequest{})
if err != nil {
return storecontract.ConfigSnapshot{}, false, unmapError(err)
}
if !reply.Found {
return storecontract.ConfigSnapshot{}, false, nil
}
return configSnapshotValue(reply.Snapshot), true, nil
}
// PutChannelStatus publishes the channel state the hosting process observes.
// Administrative, like the config snapshot pair: the server admits it on the
// administrative token only, so a task-scoped grant cannot reach it.
func (c *Client) PutChannelStatus(ctx context.Context, channels []storecontract.ChannelStatus) error {
_, err := c.client.PutChannelStatus(ctx, &pb.PutChannelStatusRequest{Channels: channelStatusesProto(channels)})
if err != nil {
return unmapError(err)
}
return nil
}
// ChannelStatus reads every reported channel.
func (c *Client) ChannelStatus(ctx context.Context) ([]storecontract.ChannelStatus, error) {
reply, err := c.client.ListChannelStatus(ctx, &pb.ListChannelStatusRequest{})
if err != nil {
return nil, unmapError(err)
}
return channelStatusesValue(reply.Channels), nil
}
// PutApplyStatus reports what this process applied for one resource kind.
// Administrative, like the config snapshot pair: a task-scoped grant cannot
// reach it.
func (c *Client) PutApplyStatus(ctx context.Context, status storecontract.ApplyStatus) error {
_, err := c.client.PutApplyStatus(ctx, &pb.PutApplyStatusRequest{Status: applyStatusProto(status)})
if err != nil {
return unmapError(err)
}
return nil
}
// ListApplyStatus reads every process's report. An empty slice means nothing
// has reported yet, which is not an error.
func (c *Client) ListApplyStatus(ctx context.Context) ([]storecontract.ApplyStatus, error) {
reply, err := c.client.ListApplyStatus(ctx, &pb.ListApplyStatusRequest{})
if err != nil {
return nil, unmapError(err)
}
statuses := make([]storecontract.ApplyStatus, 0, len(reply.Statuses))
for _, status := range reply.Statuses {
statuses = append(statuses, applyStatusValue(status))
}
return statuses, nil
}
// ListCaptures streams one capture per message; see StreamCaptures in
// server.go.
func (c *Client) ListCaptures(ctx context.Context, limit int) ([]storecontract.CapturedEvent, error) {
stream, err := c.client.StreamCaptures(ctx, &pb.StreamCapturesRequest{Limit: int64(limit)})
if err != nil {
return nil, unmapError(err)
}
var captures []storecontract.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
func (c *Client) InsertMapping(ctx context.Context, m mapping.Mapping) (string, error) {
r, err := c.client.InsertMapping(ctx, &pb.InsertMappingRequest{Mapping: mappingProto(m)})
if err != nil {
return "", unmapError(err)
}
return r.Id, nil
}
func (c *Client) GetMapping(ctx context.Context, id string) (*mapping.Mapping, error) {
r, err := c.client.GetMapping(ctx, &pb.GetMappingRequest{Id: id})
if err != nil {
return nil, unmapError(err)
}
if !r.Found {
return nil, nil
}
v := mappingValue(r.Mapping)
return &v, nil
}
func (c *Client) ListMappings(ctx context.Context) ([]mapping.Mapping, error) {
r, err := c.client.ListMappings(ctx, &pb.ListMappingsRequest{})
if err != nil {
return nil, unmapError(err)
}
return mapValues(r.Mappings, mappingValue), nil
}
func (c *Client) UpdateMapping(ctx context.Context, m mapping.Mapping) error {
_, err := c.client.UpdateMapping(ctx, &pb.UpdateMappingRequest{Mapping: mappingProto(m)})
return unmapError(err)
}
func (c *Client) DeleteMapping(ctx context.Context, id string) error {
_, err := c.client.DeleteMapping(ctx, &pb.DeleteMappingRequest{Id: id})
return unmapError(err)
}
func (c *Client) RecordMappingMatch(ctx context.Context, mappingID, captureID string) error {
_, err := c.client.RecordMappingMatch(ctx, &pb.RecordMappingMatchRequest{MappingId: mappingID, CaptureId: captureID})
return unmapError(err)
}
// Binding
func (c *Client) InsertBinding(ctx context.Context, b binding.Binding) (string, error) {
r, err := c.client.InsertBinding(ctx, &pb.InsertBindingRequest{Binding: bindingProto(b)})
if err != nil {
return "", unmapError(err)
}
return r.Id, nil
}
func (c *Client) GetBinding(ctx context.Context, id string) (*binding.Binding, error) {
r, err := c.client.GetBinding(ctx, &pb.GetBindingRequest{Id: id})
if err != nil {
return nil, unmapError(err)
}
if !r.Found {
return nil, nil
}
v := bindingValue(r.Binding)
return &v, nil
}
func (c *Client) ListBindings(ctx context.Context) ([]binding.Binding, error) {
r, err := c.client.ListBindings(ctx, &pb.ListBindingsRequest{})
if err != nil {
return nil, unmapError(err)
}
return mapValues(r.Bindings, bindingValue), nil
}
func (c *Client) UpdateBinding(ctx context.Context, b binding.Binding) error {
_, err := c.client.UpdateBinding(ctx, &pb.UpdateBindingRequest{Binding: bindingProto(b)})
return unmapError(err)
}
func (c *Client) DeleteBinding(ctx context.Context, id string) error {
_, err := c.client.DeleteBinding(ctx, &pb.DeleteBindingRequest{Id: id})
return unmapError(err)
}
func (c *Client) ApproveBinding(ctx context.Context, id string) error {
_, err := c.client.ApproveBinding(ctx, &pb.ApproveBindingRequest{Id: id})
return unmapError(err)
}
// Source
func (c *Client) InsertSource(ctx context.Context, s source.Source) error {
_, err := c.client.InsertSource(ctx, &pb.InsertSourceRequest{Source: sourceProto(s)})
return unmapError(err)
}
func (c *Client) GetSource(ctx context.Context, path string) (*source.Source, error) {
r, err := c.client.GetSource(ctx, &pb.GetSourceRequest{Path: path})
if err != nil {
return nil, unmapError(err)
}
if !r.Found {
return nil, nil
}
v := sourceValue(r.Source)
return &v, nil
}
func (c *Client) ListSources(ctx context.Context) ([]source.Source, error) {
r, err := c.client.ListSources(ctx, &pb.ListSourcesRequest{})
if err != nil {
return nil, unmapError(err)
}
return mapValues(r.Sources, sourceValue), nil
}
func (c *Client) SetSourceSigning(ctx context.Context, path string, from, to source.Signing) error {
_, err := c.client.SetSourceSigning(ctx, &pb.SetSourceSigningRequest{Path: path, From: string(from), To: string(to)})
return unmapError(err)
}
func (c *Client) SetSourceSecret(ctx context.Context, path, secret string) error {
_, err := c.client.SetSourceSecret(ctx, &pb.SetSourceSecretRequest{Path: path, Secret: secret})
return unmapError(err)
}
// Dispatch
func (c *Client) ArmedBindingsForSource(ctx context.Context, source string) ([]binding.Binding, error) {
r, err := c.client.ArmedBindingsForSource(ctx, &pb.ArmedBindingsForSourceRequest{Source: source})
if err != nil {
return nil, unmapError(err)
}
return mapValues(r.Bindings, bindingValue), nil
}
func (c *Client) RecordDispatch(ctx context.Context, bindingID string, bindingVersion int64, captureID string, taskID int64) error {
_, err := c.client.RecordDispatch(ctx, &pb.RecordDispatchRequest{BindingId: bindingID, BindingVersion: bindingVersion, CaptureId: captureID, TaskId: taskID})
return unmapError(err)
}
// Playbook dispatch
func (c *Client) RecordPlaybookDispatch(ctx context.Context, playbookID, playbookVersion, eventID, actionID string) error {
_, err := c.client.RecordPlaybookDispatch(ctx, &pb.RecordPlaybookDispatchRequest{PlaybookId: playbookID, PlaybookVersion: playbookVersion, EventId: eventID, ActionId: actionID})
return unmapError(err)
}
func (c *Client) DeletePlaybookDispatches(ctx context.Context, playbookID string) error {
_, err := c.client.DeletePlaybookDispatches(ctx, &pb.DeletePlaybookDispatchesRequest{PlaybookId: playbookID})
return unmapError(err)
}
// ListUndispatchedCaptures streams for the same reason as ListCaptures.
func (c *Client) ListUndispatchedCaptures(ctx context.Context, sources []string, limit int) ([]storecontract.CapturedEvent, error) {
stream, err := c.client.StreamUndispatchedCaptures(ctx, &pb.StreamUndispatchedCapturesRequest{Sources: sources, Limit: int64(limit)})
if err != nil {
return nil, unmapError(err)
}
var captures []storecontract.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
func (c *Client) EnqueueBindingTask(ctx context.Context, owner, repo, title, body, wf, identity, bindingID string, bindingVersion int, inputs map[string]any) (*task.Task, error) {
encoded, err := task.EncodeInputs(inputs)
if err != nil {
return nil, err
}
r, err := c.client.EnqueueBindingTask(ctx, &pb.EnqueueBindingTaskRequest{Owner: owner, Repo: repo, Title: title, Body: body, Workflow: wf, Identity: identity, BindingId: bindingID, BindingVersion: int64(bindingVersion), InputsJson: encoded})
if err != nil {
return nil, unmapError(err)
}
return taskValue(r.Task), nil
}
// WorkflowCaller: the workflow.call step's two RPCs (docs/prds/
// workflow-calls.md). StartCall encodes the call's inputs in the same form
// every other wire crossing uses; CallStatus rehydrates the sentinels the
// server maps, so a caller's errors.Is(err, storecontract.ErrCallNotYours)
// works across the wire.
func (c *Client) StartCall(ctx context.Context, callerTaskID int64, wf string, inputs map[string]any) (*task.Task, error) {
encoded, err := task.EncodeInputs(inputs)
if err != nil {
return nil, err
}
r, err := c.client.EnqueueCallTask(ctx, &pb.EnqueueCallTaskRequest{CallerTaskId: callerTaskID, Workflow: wf, InputsJson: encoded})
if err != nil {
return nil, unmapError(err)
}
return taskValue(r.Task), nil
}
func (c *Client) CallStatus(ctx context.Context, callerTaskID, callTaskID int64) (string, string, error) {
r, err := c.client.WorkflowCallStatus(ctx, &pb.WorkflowCallStatusRequest{CallerTaskId: callerTaskID, CallTaskId: callTaskID})
if err != nil {
return "", "", unmapError(err)
}
return r.Status, r.Detail, nil
}
// Task log
// TaskLog reads one task attempt's decoded log over the wire. found=false with
// a nil error is the attempt-has-no-log answer; a process with no reader at
// all comes back as an unavailable error, not as an empty page, so a caller
// can tell the two apart.
func (c *Client) TaskLog(ctx context.Context, taskID int64, attempt int, q logging.Query) (logging.TaskLogPage, error) {
r, err := c.client.ReadTaskLog(ctx, taskLogRequestProto(taskID, attempt, q))
if err != nil {
return logging.TaskLogPage{}, unmapError(err)
}
if !r.Found {
return logging.TaskLogPage{
Entries: []logging.Entry{},
Components: []string{},
}, nil
}
// Both collections are normalised: protobuf decodes an empty `repeated`
// field to nil, and a nil slice marshals to JSON null rather than an empty
// list, so the field's type would otherwise depend on whether it happened
// to have contents. mapValues owns the entries side.
components := r.Components
if components == nil {
components = []string{}
}
return logging.TaskLogPage{
Entries: mapValues(r.Entries, taskLogEntryValue),
Truncated: r.Truncated,
File: r.File,
Found: true,
Components: components,
}, nil
}
// TaskLogContent streams one attempt's log verbatim into w, for a download.
// found is false, with a nil error, when the attempt has no log file.
func (c *Client) TaskLogContent(ctx context.Context, taskID int64, attempt int, w io.Writer) (bool, error) {
stream, err := c.client.StreamTaskLogContent(ctx, &pb.StreamTaskLogContentRequest{TaskId: taskID, Attempt: int64(attempt)})
if err != nil {
return false, unmapError(err)
}
found := false
for {
r, err := stream.Recv()
if errors.Is(err, io.EOF) {
return found, nil
}
if err != nil {
return found, unmapError(err)
}
found = found || r.Found
if len(r.Chunk) == 0 {
continue
}
if _, err := w.Write(r.Chunk); err != nil {
return found, err
}
}
}
// GetHarnessSecret returns the stored OAuth token set for an org/service
// credential binding, or storecontract.ErrHarnessSecretNotFound.
func (c *Client) GetHarnessSecret(ctx context.Context, org, service string) (harnesssecret.Secret, error) {
r, err := c.client.GetHarnessSecret(ctx, &pb.GetHarnessSecretRequest{Org: org, Service: service})
if err != nil {
return harnesssecret.Secret{}, unmapError(err)
}
return harnessSecretValue(r.Secret), nil
}
// PutHarnessSecret upserts an org/service credential binding's OAuth token
// set, called by the setup terminal's first capture and by the egress
// proxy's every refresh.
func (c *Client) PutHarnessSecret(ctx context.Context, s harnesssecret.Secret) error {
_, err := c.client.PutHarnessSecret(ctx, &pb.PutHarnessSecretRequest{Secret: harnessSecretProto(s)})
return unmapError(err)
}
func derefTasks(in []*pb.Task) []task.Task {
if in == nil {
return nil
}
out := make([]task.Task, len(in))
for i, t := range in {
out[i] = *taskValue(t)
}
return out
}