Archie runs its own agent loop only. Removes Kit resolution and launch, the harness runner and adapters, the setup terminal and sandbox view, harness secrets and OAuth capture (table dropped in migration 0075), the task-tools contract that only Kit containers reached, and the sandbox-kit-spec dependency. Agent profiles carry image and tools only. The egress proxy keeps the model-session path; the sandbox relay code stays for #1867.
697 lines
26 KiB
Go
697 lines
26 KiB
Go
package staterpc
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
"google.golang.org/protobuf/types/known/timestamppb"
|
|
|
|
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/binding"
|
|
"github.com/samcharles93/archie-core/internal/domain/eventtype"
|
|
"github.com/samcharles93/archie-core/internal/domain/health"
|
|
"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/workflow/task"
|
|
"github.com/samcharles93/archie-core/internal/events"
|
|
"github.com/samcharles93/archie-core/internal/logging"
|
|
"github.com/samcharles93/archie-core/internal/taskstate"
|
|
)
|
|
|
|
func timestamp(t time.Time) *timestamppb.Timestamp {
|
|
if t.IsZero() {
|
|
return nil
|
|
}
|
|
return timestamppb.New(t)
|
|
}
|
|
|
|
func timeValue(t *timestamppb.Timestamp) time.Time {
|
|
if t == nil {
|
|
return time.Time{}
|
|
}
|
|
return t.AsTime()
|
|
}
|
|
|
|
// mapValues maps a slice, returning an empty non-nil slice for empty input.
|
|
func mapValues[A, B any](in []A, f func(A) B) []B {
|
|
if len(in) == 0 {
|
|
return []B{}
|
|
}
|
|
out := make([]B, len(in))
|
|
for i, v := range in {
|
|
out[i] = f(v)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func taskProto(t *task.Task) *pb.Task { // mirror-image field-by-field proto<->domain mapping; taskValue below reverses every assignment, so line-level duplication is unavoidable without reflection
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
return &pb.Task{
|
|
Id: t.ID, Owner: t.Owner, Repo: t.Repo, IssueNumber: int64(t.IssueNumber),
|
|
Title: t.Title, Body: t.Body, Labels: t.Labels, Status: t.Status,
|
|
Workflow: t.Workflow, Branch: t.Branch, Plan: t.Plan, PlanDocument: t.PlanDocument, Notes: t.Notes,
|
|
PrNumber: int64(t.PRNumber), TokensUsed: int64(t.TokensUsed), Iterations: int64(t.Iterations),
|
|
Attempt: int64(t.Attempt), ParkReason: t.ParkReason, RetryCount: int64(t.RetryCount),
|
|
RetryMode: t.RetryMode,
|
|
ResumeFrom: t.ResumeFrom, ResumeResults: t.ResumeResults, ResumeHistory: t.ResumeHistory,
|
|
WatchCommentId: t.WatchCommentID, Source: t.Source, Identity: t.Identity,
|
|
BindingId: t.BindingID, BindingVersion: int64(t.BindingVersion),
|
|
InputsJson: inputsJSON(t.Inputs),
|
|
OutputsJson: outputsJSON(t.Outputs),
|
|
CreatedAt: timestamp(t.CreatedAt), UpdatedAt: timestamp(t.UpdatedAt),
|
|
ReviewPayload: t.ReviewPayload,
|
|
ReviewGate: t.ReviewGate,
|
|
RereviewRounds: int64(t.RereviewRounds),
|
|
ReviewCursor: t.ReviewCursor,
|
|
ParkClass: t.ParkClass,
|
|
ParkBlocker: t.ParkBlocker,
|
|
RemediationRounds: int32(t.RemediationRounds),
|
|
WorkflowDefinitionVersion: t.WorkflowDefinitionVersion,
|
|
WorkflowDefinitionDigest: t.WorkflowDefinitionDigest,
|
|
WorkflowDefinitionYaml: t.WorkflowDefinitionYAML,
|
|
Org: string(t.Org),
|
|
Workspace: string(t.Workspace),
|
|
CallParentTaskId: t.CallParentTaskID,
|
|
HandoffFromTaskId: t.HandoffFromTaskID,
|
|
HandoffToTaskId: t.HandoffToTaskID,
|
|
CallDepth: int32(t.CallDepth),
|
|
Origin: t.Origin,
|
|
BindingSignature: t.BindingSignature,
|
|
BindingAddr: t.BindingAddr,
|
|
}
|
|
}
|
|
|
|
func taskValue(t *pb.Task) *task.Task { // see taskProto above
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
return &task.Task{
|
|
ID: t.Id, Owner: t.Owner, Repo: t.Repo, IssueNumber: int(t.IssueNumber),
|
|
Title: t.Title, Body: t.Body, Labels: t.Labels, Status: t.Status,
|
|
Workflow: t.Workflow, Branch: t.Branch, Plan: t.Plan, PlanDocument: t.PlanDocument, Notes: t.Notes,
|
|
PRNumber: int(t.PrNumber), TokensUsed: int(t.TokensUsed), Iterations: int(t.Iterations),
|
|
Attempt: int(t.Attempt), ParkReason: t.ParkReason, RetryCount: int(t.RetryCount),
|
|
RetryMode: t.RetryMode,
|
|
ResumeFrom: t.ResumeFrom, ResumeResults: t.ResumeResults, ResumeHistory: t.ResumeHistory,
|
|
WatchCommentID: t.WatchCommentId, Source: t.Source, Identity: t.Identity,
|
|
BindingID: t.BindingId, BindingVersion: int(t.BindingVersion),
|
|
Inputs: inputsValue(t.InputsJson),
|
|
Outputs: outputsValue(t.OutputsJson),
|
|
CreatedAt: timeValue(t.CreatedAt), UpdatedAt: timeValue(t.UpdatedAt),
|
|
ReviewPayload: t.ReviewPayload,
|
|
ReviewGate: t.ReviewGate,
|
|
RereviewRounds: int(t.RereviewRounds),
|
|
ReviewCursor: t.ReviewCursor,
|
|
ParkClass: t.ParkClass,
|
|
ParkBlocker: t.ParkBlocker,
|
|
RemediationRounds: int(t.RemediationRounds),
|
|
WorkflowDefinitionVersion: t.WorkflowDefinitionVersion,
|
|
WorkflowDefinitionDigest: t.WorkflowDefinitionDigest,
|
|
WorkflowDefinitionYAML: t.WorkflowDefinitionYaml,
|
|
Org: org.OrgID(t.Org),
|
|
Workspace: org.WorkspaceID(t.Workspace),
|
|
CallParentTaskID: t.CallParentTaskId,
|
|
HandoffFromTaskID: t.HandoffFromTaskId,
|
|
HandoffToTaskID: t.HandoffToTaskId,
|
|
CallDepth: int(t.CallDepth),
|
|
Origin: t.Origin,
|
|
BindingSignature: t.BindingSignature,
|
|
BindingAddr: t.BindingAddr,
|
|
}
|
|
}
|
|
|
|
// inputsJSON and inputsValue carry task inputs in task.EncodeInputs form.
|
|
// Both ends encode with EncodeInputs, so neither direction can fail on a
|
|
// value this contract produced.
|
|
func inputsJSON(inputs map[string]any) string {
|
|
s, _ := task.EncodeInputs(inputs)
|
|
return s
|
|
}
|
|
|
|
func inputsValue(s string) map[string]any {
|
|
inputs, _ := task.DecodeInputs(s)
|
|
return inputs
|
|
}
|
|
|
|
// outputsJSON and outputsValue carry a task's written outputs in
|
|
// task.EncodeOutputs form, exactly as inputsJSON/inputsValue carry inputs.
|
|
func outputsJSON(outputs map[string]any) string {
|
|
s, _ := task.EncodeOutputs(outputs)
|
|
return s
|
|
}
|
|
|
|
func outputsValue(s string) map[string]any {
|
|
outputs, _ := task.DecodeOutputs(s)
|
|
return outputs
|
|
}
|
|
|
|
// eventDataJSON and eventDataValue convert events.Event.Data (map[string]any)
|
|
// to/from a JSON object string, mirroring the store's own on-disk column.
|
|
func eventDataJSON(data map[string]any) string {
|
|
if data == nil {
|
|
return ""
|
|
}
|
|
b, err := json.Marshal(data)
|
|
if err != nil {
|
|
return fmt.Sprintf(`{"marshal_error":%q}`, err.Error())
|
|
}
|
|
return string(b)
|
|
}
|
|
|
|
func eventDataValue(s string) map[string]any {
|
|
if s == "" {
|
|
return nil
|
|
}
|
|
var data map[string]any
|
|
if err := json.Unmarshal([]byte(s), &data); err != nil {
|
|
return nil
|
|
}
|
|
return data
|
|
}
|
|
|
|
func eventProto(e events.Event) *pb.Event {
|
|
return &pb.Event{
|
|
Id: e.ID, At: timestamp(e.At), Kind: e.Kind, TaskId: e.TaskID, Repo: e.Repo,
|
|
Issue: int64(e.Issue), Workflow: e.Workflow, Stage: e.Stage, Attempt: int64(e.Attempt),
|
|
Detail: e.Detail, DataJson: eventDataJSON(e.Data),
|
|
ActorId: e.ActorID, ActorKind: e.ActorKind, PrincipalId: e.PrincipalID,
|
|
}
|
|
}
|
|
|
|
func eventValue(e *pb.Event) events.Event {
|
|
if e == nil {
|
|
return events.Event{}
|
|
}
|
|
return events.Event{
|
|
ID: e.Id, At: timeValue(e.At), Kind: e.Kind, TaskID: e.TaskId, Repo: e.Repo,
|
|
Issue: int(e.Issue), Workflow: e.Workflow, Stage: e.Stage, Attempt: int(e.Attempt),
|
|
Detail: e.Detail, Data: eventDataValue(e.DataJson),
|
|
ActorID: e.ActorId, ActorKind: e.ActorKind, PrincipalID: e.PrincipalId,
|
|
}
|
|
}
|
|
|
|
func capturedEventProto(c storecontract.CapturedEvent) *pb.CapturedEvent {
|
|
return &pb.CapturedEvent{
|
|
Id: c.ID, ReceivedAt: timestamp(c.ReceivedAt), Source: c.Source,
|
|
RemoteAddr: c.RemoteAddr, ContentType: c.ContentType, Headers: c.Headers,
|
|
Body: c.Body, Authenticated: c.Authenticated, EventType: c.EventType,
|
|
Unsigned: c.Unsigned, Delivery: c.Delivery, OrgId: c.OrgID,
|
|
}
|
|
}
|
|
|
|
func capturedEventValue(c *pb.CapturedEvent) storecontract.CapturedEvent {
|
|
if c == nil {
|
|
return storecontract.CapturedEvent{}
|
|
}
|
|
return storecontract.CapturedEvent{
|
|
ID: c.Id, ReceivedAt: timeValue(c.ReceivedAt), Source: c.Source,
|
|
RemoteAddr: c.RemoteAddr, ContentType: c.ContentType, Headers: c.Headers,
|
|
Body: c.Body, Authenticated: c.Authenticated, EventType: c.EventType,
|
|
Unsigned: c.Unsigned, Delivery: c.Delivery, OrgID: c.OrgId,
|
|
}
|
|
}
|
|
|
|
func sourceProto(s source.Source) *pb.Source {
|
|
return &pb.Source{
|
|
Path: s.Path, Name: s.Name, DeliveryHeader: s.DeliveryHeader, Signing: string(s.Signing), Secret: s.Secret,
|
|
OrgId: string(s.OrgID), WorkspaceId: string(s.WorkspaceID),
|
|
CreatedAt: timestamp(s.CreatedAt), UpdatedAt: timestamp(s.UpdatedAt),
|
|
}
|
|
}
|
|
|
|
func sourceValue(s *pb.Source) source.Source {
|
|
if s == nil {
|
|
return source.Source{}
|
|
}
|
|
return source.Source{
|
|
Path: s.Path, Name: s.Name, DeliveryHeader: s.DeliveryHeader, Signing: source.Signing(s.Signing), Secret: s.Secret,
|
|
OrgID: org.OrgID(s.OrgId), WorkspaceID: org.WorkspaceID(s.WorkspaceId),
|
|
CreatedAt: timeValue(s.CreatedAt), UpdatedAt: timeValue(s.UpdatedAt),
|
|
}
|
|
}
|
|
|
|
func mappingFieldProto(f mapping.Field) *pb.MappingField {
|
|
return &pb.MappingField{Name: f.Name, Path: f.Path, Type: string(f.Type), Required: f.Required}
|
|
}
|
|
|
|
func mappingFieldValue(f *pb.MappingField) mapping.Field {
|
|
if f == nil {
|
|
return mapping.Field{}
|
|
}
|
|
return mapping.Field{Name: f.Name, Path: f.Path, Type: mapping.FieldType(f.Type), Required: f.Required}
|
|
}
|
|
|
|
func mappingProto(m mapping.Mapping) *pb.Mapping {
|
|
return &pb.Mapping{
|
|
Id: m.ID, Name: m.Name, SourceHint: m.SourceHint, EventTypeId: m.EventTypeID,
|
|
WorkspaceId: string(m.WorkspaceID),
|
|
Fields: mapValues(m.Fields, mappingFieldProto),
|
|
MatchCount: m.MatchCount, LastMatchedAt: timestamp(m.LastMatchedAt),
|
|
CreatedAt: timestamp(m.CreatedAt), UpdatedAt: timestamp(m.UpdatedAt),
|
|
}
|
|
}
|
|
|
|
func mappingValue(m *pb.Mapping) mapping.Mapping {
|
|
if m == nil {
|
|
return mapping.Mapping{}
|
|
}
|
|
return mapping.Mapping{
|
|
ID: m.Id, Name: m.Name, SourceHint: m.SourceHint, EventTypeID: m.EventTypeId,
|
|
WorkspaceID: org.WorkspaceID(m.WorkspaceId),
|
|
Fields: mapValues(m.Fields, mappingFieldValue),
|
|
MatchCount: m.MatchCount, LastMatchedAt: timeValue(m.LastMatchedAt),
|
|
CreatedAt: timeValue(m.CreatedAt), UpdatedAt: timeValue(m.UpdatedAt),
|
|
}
|
|
}
|
|
|
|
func bindingProto(b binding.Binding) *pb.Binding {
|
|
return &pb.Binding{
|
|
Id: b.ID, Name: b.Name, Matcher: &pb.BindingMatcher{Source: b.Matcher.Source},
|
|
MappingId: b.MappingID, Filter: b.Filter, Workflow: b.Workflow, Owner: b.Owner, Repo: b.Repo,
|
|
RepoParam: b.RepoParam, InputsJson: bindingInputsJSON(b.Inputs), OrgId: string(b.OrgID),
|
|
WorkspaceId: string(b.WorkspaceID), Version: int64(b.Version), Status: string(b.Status),
|
|
CreatedAt: timestamp(b.CreatedAt), UpdatedAt: timestamp(b.UpdatedAt),
|
|
}
|
|
}
|
|
|
|
func bindingValue(b *pb.Binding) binding.Binding {
|
|
if b == nil {
|
|
return binding.Binding{}
|
|
}
|
|
var source string
|
|
if b.Matcher != nil {
|
|
source = b.Matcher.Source
|
|
}
|
|
return binding.Binding{
|
|
ID: b.Id, Name: b.Name, Matcher: binding.Matcher{Source: source},
|
|
MappingID: b.MappingId, Filter: b.Filter, Workflow: b.Workflow, Owner: b.Owner, Repo: b.Repo,
|
|
RepoParam: b.RepoParam, Inputs: bindingInputsValue(b.InputsJson), OrgID: org.OrgID(b.OrgId),
|
|
WorkspaceID: org.WorkspaceID(b.WorkspaceId), Version: int(b.Version), Status: binding.Status(b.Status),
|
|
CreatedAt: timeValue(b.CreatedAt), UpdatedAt: timeValue(b.UpdatedAt),
|
|
}
|
|
}
|
|
|
|
// bindingInputsJSON and bindingInputsValue carry a binding's input
|
|
// assignments as JSON. The domain type always marshals, and the client only
|
|
// decodes what the server marshalled.
|
|
func bindingInputsJSON(inputs map[string]binding.InputSource) string {
|
|
if len(inputs) == 0 {
|
|
return ""
|
|
}
|
|
data, _ := json.Marshal(inputs)
|
|
return string(data)
|
|
}
|
|
|
|
func bindingInputsValue(s string) map[string]binding.InputSource {
|
|
if s == "" {
|
|
return nil
|
|
}
|
|
var inputs map[string]binding.InputSource
|
|
_ = json.Unmarshal([]byte(s), &inputs)
|
|
return inputs
|
|
}
|
|
|
|
func workflowStatProto(w storecontract.WorkflowStat) *pb.WorkflowStat {
|
|
return &pb.WorkflowStat{
|
|
Workflow: w.Workflow, Runs: int64(w.Runs), Merged: int64(w.Merged),
|
|
Completed: int64(w.Completed), PrOpen: int64(w.PROpen), Parked: int64(w.Parked),
|
|
AvgTokens: int64(w.AvgTokens), AvgSteps: w.AvgSteps, TotalTokens: int64(w.TotalToken),
|
|
Running: int64(w.Running), LastStatus: w.LastStatus,
|
|
}
|
|
}
|
|
|
|
func workflowStatValue(w *pb.WorkflowStat) storecontract.WorkflowStat {
|
|
if w == nil {
|
|
return storecontract.WorkflowStat{}
|
|
}
|
|
return storecontract.WorkflowStat{
|
|
Workflow: w.Workflow, Runs: int(w.Runs), Merged: int(w.Merged),
|
|
Completed: int(w.Completed), PROpen: int(w.PrOpen), Parked: int(w.Parked),
|
|
AvgTokens: int(w.AvgTokens), AvgSteps: w.AvgSteps, TotalToken: int(w.TotalTokens),
|
|
Running: int(w.Running), LastStatus: w.LastStatus,
|
|
}
|
|
}
|
|
|
|
func stepExecutionProto(s task.StepExecution) *pb.StepExecution {
|
|
return &pb.StepExecution{
|
|
Id: s.ID, ExecutionId: s.ExecutionID, Attempt: int64(s.Attempt),
|
|
ParentId: s.ParentID, Depth: int32(s.Depth), Kind: s.Kind, Name: s.Name,
|
|
Status: string(s.Status), Detail: s.Detail, TokensUsed: s.TokensUsed,
|
|
StartedAt: timestamp(s.StartedAt), FinishedAt: timestamp(s.FinishedAt),
|
|
CalledExecutionId: s.CalledExecutionID,
|
|
}
|
|
}
|
|
|
|
func stepExecutionValue(s *pb.StepExecution) task.StepExecution {
|
|
if s == nil {
|
|
return task.StepExecution{}
|
|
}
|
|
return task.StepExecution{
|
|
ID: s.Id, ExecutionID: s.ExecutionId, Attempt: int(s.Attempt),
|
|
ParentID: s.ParentId, Depth: int(s.Depth), Kind: s.Kind, Name: s.Name,
|
|
Status: taskstate.StepStatus(s.Status), Detail: s.Detail, TokensUsed: s.TokensUsed,
|
|
StartedAt: timeValue(s.StartedAt), FinishedAt: timeValue(s.FinishedAt),
|
|
CalledExecutionID: s.CalledExecutionId,
|
|
}
|
|
}
|
|
|
|
func stageStatProto(s storecontract.StageStat) *pb.StageStat {
|
|
return &pb.StageStat{Workflow: s.Workflow, Stage: s.Stage, Runs: int64(s.Runs), AvgMs: int64(s.AvgMs), Errors: int64(s.Errors)}
|
|
}
|
|
|
|
func stageStatValue(s *pb.StageStat) storecontract.StageStat {
|
|
if s == nil {
|
|
return storecontract.StageStat{}
|
|
}
|
|
return storecontract.StageStat{Workflow: s.Workflow, Stage: s.Stage, Runs: int(s.Runs), AvgMs: int(s.AvgMs), Errors: int(s.Errors)}
|
|
}
|
|
|
|
func dayTokensProto(d storecontract.DayTokens) *pb.DayTokens {
|
|
return &pb.DayTokens{Day: d.Day, Tokens: int64(d.Tokens)}
|
|
}
|
|
|
|
func dayTokensValue(d *pb.DayTokens) storecontract.DayTokens {
|
|
if d == nil {
|
|
return storecontract.DayTokens{}
|
|
}
|
|
return storecontract.DayTokens{Day: d.Day, Tokens: int(d.Tokens)}
|
|
}
|
|
|
|
// Canonical public phrases for sentinel errors. These strings
|
|
// are the wire contract for sentinel identity -- the client rehydrates by
|
|
// matching (code, message), never by parsing free-form text.
|
|
const (
|
|
msgStaleTransition = "stale transition"
|
|
msgIllegalTransition = "illegal transition"
|
|
msgInvalidStep = "step execution invalid"
|
|
msgBindingNotFound = "binding not found"
|
|
msgMappingNotFound = "mapping not found"
|
|
msgEventTypeNotFound = "event type not found"
|
|
msgEventTypeOverlap = "event type overlap"
|
|
msgEventTypeInvalid = "event type invalid"
|
|
msgBindingOverlap = "binding overlap"
|
|
msgBindingTransition = "binding transition rejected"
|
|
msgAlreadyDispatched = "already dispatched"
|
|
msgSourceNotFound = "source not found"
|
|
msgSourcePathTaken = "source path taken"
|
|
msgSourceSigning = "source signing stale"
|
|
// msgRereviewCapReached is the canonical message of
|
|
// storecontract.ErrRereviewCapReached on the wire. Changing it breaks
|
|
// errors.Is on the client without changing behaviour visibly.
|
|
msgRereviewCapReached = "store: re-review cap reached"
|
|
msgInternal = "state store: internal error"
|
|
// msgTaskLogsUnavailable is part of the wire contract for
|
|
// ErrTaskLogsUnavailable.
|
|
msgTaskLogsUnavailable = "task log reader unavailable"
|
|
)
|
|
|
|
// mapError converts a store sentinel to a gRPC status with a stable public
|
|
// message; other errors become Internal. Context errors keep their codes.
|
|
func mapError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
if errors.Is(err, context.Canceled) {
|
|
return status.Error(codes.Canceled, context.Canceled.Error())
|
|
}
|
|
if errors.Is(err, context.DeadlineExceeded) {
|
|
return status.Error(codes.DeadlineExceeded, context.DeadlineExceeded.Error())
|
|
}
|
|
for _, w := range wireErrors {
|
|
if errors.Is(err, w.sentinel) {
|
|
return status.Error(w.code, w.message)
|
|
}
|
|
}
|
|
return status.Error(codes.Internal, msgInternal)
|
|
}
|
|
|
|
// unmapError turns a gRPC status back into its store sentinel, context error
|
|
// or ErrTaskLogsUnavailable. Non-status errors are returned unchanged.
|
|
func unmapError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
st, ok := status.FromError(err)
|
|
if !ok {
|
|
return err
|
|
}
|
|
switch st.Code() {
|
|
case codes.Canceled:
|
|
return context.Canceled
|
|
case codes.DeadlineExceeded:
|
|
return context.DeadlineExceeded
|
|
case codes.Unavailable:
|
|
// Wrap both, so a caller can retry on errors.Is(ErrUnavailable) and a
|
|
// caller that maps status codes still reads Unavailable through the
|
|
// chain.
|
|
return fmt.Errorf("%w: %w", storecontract.ErrUnavailable, err)
|
|
}
|
|
if sentinel := sentinelForStatus(st); sentinel != nil {
|
|
return sentinel
|
|
}
|
|
return fmt.Errorf("state store: %s: %w", st.Message(), err)
|
|
}
|
|
|
|
// sentinelForStatus maps a status to the store or logging sentinel it stands
|
|
// for, matched on (code, exact canonical message) -- those message constants
|
|
// are part of the wire contract. A code whose message is not one this
|
|
// package defines returns nil, so the caller falls back to the wrapped form.
|
|
func sentinelForStatus(st *status.Status) error {
|
|
return wireSentinels[wireStatus{st.Code(), st.Message()}]
|
|
}
|
|
|
|
type wireStatus struct {
|
|
code codes.Code
|
|
message string
|
|
}
|
|
|
|
// wireErrors pairs each sentinel with its canonical (code, message). mapError
|
|
// reads it forward and sentinelForStatus backward, so the two directions
|
|
// cannot drift.
|
|
var wireErrors = []struct {
|
|
sentinel error
|
|
code codes.Code
|
|
message string
|
|
}{
|
|
{storecontract.ErrStaleTransition, codes.FailedPrecondition, msgStaleTransition},
|
|
{access.ErrPolicyLockout, codes.FailedPrecondition, access.ErrPolicyLockout.Error()},
|
|
{storecontract.ErrIllegalTransition, codes.FailedPrecondition, msgIllegalTransition},
|
|
{storecontract.ErrInvalidStep, codes.InvalidArgument, msgInvalidStep},
|
|
{storecontract.ErrResumeIncomplete, codes.FailedPrecondition, storecontract.ErrResumeIncomplete.Error()},
|
|
{storecontract.ErrBindingOverlap, codes.FailedPrecondition, msgBindingOverlap},
|
|
{storecontract.ErrBindingTransition, codes.FailedPrecondition, msgBindingTransition},
|
|
{storecontract.ErrSourceSigningStale, codes.FailedPrecondition, msgSourceSigning},
|
|
{eventtype.ErrOverlap, codes.FailedPrecondition, msgEventTypeOverlap},
|
|
{eventtype.ErrInvalid, codes.InvalidArgument, msgEventTypeInvalid},
|
|
{storecontract.ErrBindingNotFound, codes.NotFound, msgBindingNotFound},
|
|
{storecontract.ErrMappingNotFound, codes.NotFound, msgMappingNotFound},
|
|
{storecontract.ErrEventTypeNotFound, codes.NotFound, msgEventTypeNotFound},
|
|
{storecontract.ErrSourceNotFound, codes.NotFound, msgSourceNotFound},
|
|
{storecontract.ErrSourceInUse, codes.FailedPrecondition, storecontract.ErrSourceInUse.Error()},
|
|
{storecontract.ErrAlreadyDispatched, codes.AlreadyExists, msgAlreadyDispatched},
|
|
{storecontract.ErrCallNotYours, codes.PermissionDenied, storecontract.ErrCallNotYours.Error()},
|
|
{storecontract.ErrCallCallerNotRunning, codes.FailedPrecondition, storecontract.ErrCallCallerNotRunning.Error()},
|
|
{storecontract.ErrCallDepthExceeded, codes.FailedPrecondition, storecontract.ErrCallDepthExceeded.Error()},
|
|
{storecontract.ErrSourcePathTaken, codes.AlreadyExists, msgSourcePathTaken},
|
|
{org.ErrInvalidWorkspace, codes.InvalidArgument, org.ErrInvalidWorkspace.Error()},
|
|
{org.ErrLastOwner, codes.FailedPrecondition, org.ErrLastOwner.Error()},
|
|
{storecontract.ErrRereviewCapReached, codes.FailedPrecondition, msgRereviewCapReached},
|
|
{storepkg.ErrNotFound, codes.NotFound, storepkg.ErrNotFound.Error()},
|
|
{storepkg.ErrInstalled, codes.AlreadyExists, storepkg.ErrInstalled.Error()},
|
|
{storepkg.ErrRequired, codes.FailedPrecondition, storepkg.ErrRequired.Error()},
|
|
{storepkg.ErrAuthorityNotDeclared, codes.FailedPrecondition, storepkg.ErrAuthorityNotDeclared.Error()},
|
|
{storepkg.ErrNoPendingUpdate, codes.FailedPrecondition, storepkg.ErrNoPendingUpdate.Error()},
|
|
{storepkg.ErrInvalidPolicy, codes.InvalidArgument, storepkg.ErrInvalidPolicy.Error()},
|
|
{storepkg.ErrNoPrevious, codes.FailedPrecondition, storepkg.ErrNoPrevious.Error()},
|
|
{storepkg.ErrContributionCollision, codes.InvalidArgument, storepkg.ErrContributionCollision.Error()},
|
|
{logging.ErrTaskLogsUnavailable, codes.Unavailable, msgTaskLogsUnavailable},
|
|
}
|
|
|
|
// wireSentinels indexes wireErrors by (code, canonical message).
|
|
var wireSentinels = func() map[wireStatus]error {
|
|
m := make(map[wireStatus]error, len(wireErrors))
|
|
for _, w := range wireErrors {
|
|
m[wireStatus{w.code, w.message}] = w.sentinel
|
|
}
|
|
return m
|
|
}()
|
|
|
|
// configSnapshotProto and configSnapshotValue carry the dashboard's
|
|
// configuration projection. document crosses as bytes, unread by either side
|
|
// of this hop: the store holds it and the page renders it.
|
|
func configSnapshotProto(snapshot storecontract.ConfigSnapshot) *pb.ConfigSnapshot {
|
|
return &pb.ConfigSnapshot{
|
|
Schema: snapshot.Schema,
|
|
Document: snapshot.Document,
|
|
PublishedAt: timestamp(snapshot.PublishedAt),
|
|
}
|
|
}
|
|
|
|
func configSnapshotValue(snapshot *pb.ConfigSnapshot) storecontract.ConfigSnapshot {
|
|
if snapshot == nil {
|
|
return storecontract.ConfigSnapshot{}
|
|
}
|
|
return storecontract.ConfigSnapshot{
|
|
Schema: snapshot.Schema,
|
|
Document: snapshot.Document,
|
|
PublishedAt: timeValue(snapshot.PublishedAt),
|
|
}
|
|
}
|
|
|
|
// channelStatusesProto and channelStatusesValue carry the channel runtime state
|
|
// the hosting process reports. The state is a string rather than an enum on the
|
|
// wire: the vocabulary belongs to internal/channels/status, and a reader that
|
|
// does not know a state it receives must show it rather than reject the report.
|
|
func channelStatusesProto(channels []storecontract.ChannelStatus) []*pb.ChannelStatus {
|
|
out := make([]*pb.ChannelStatus, 0, len(channels))
|
|
for _, channel := range channels {
|
|
out = append(out, &pb.ChannelStatus{
|
|
Id: channel.ID,
|
|
Name: channel.Name,
|
|
State: channel.State,
|
|
Detail: channel.Detail,
|
|
Configured: channel.Configured,
|
|
ReloadSupported: channel.ReloadSupported,
|
|
ObservedAt: timestamp(channel.ObservedAt),
|
|
})
|
|
}
|
|
return out
|
|
}
|
|
|
|
func channelStatusesValue(channels []*pb.ChannelStatus) []storecontract.ChannelStatus {
|
|
out := make([]storecontract.ChannelStatus, 0, len(channels))
|
|
for _, channel := range channels {
|
|
if channel == nil {
|
|
continue
|
|
}
|
|
out = append(out, storecontract.ChannelStatus{
|
|
ID: channel.Id,
|
|
Name: channel.Name,
|
|
State: channel.State,
|
|
Detail: channel.Detail,
|
|
Configured: channel.Configured,
|
|
ReloadSupported: channel.ReloadSupported,
|
|
ObservedAt: timeValue(channel.ObservedAt),
|
|
})
|
|
}
|
|
return out
|
|
}
|
|
|
|
func applyStatusProto(status storecontract.ApplyStatus) *pb.ApplyStatus {
|
|
return &pb.ApplyStatus{
|
|
Process: status.Process,
|
|
Kind: status.Kind,
|
|
AppliedVersion: status.AppliedVersion,
|
|
Error: status.Error,
|
|
ReportedAt: timestamp(status.ReportedAt),
|
|
}
|
|
}
|
|
|
|
func applyStatusValue(status *pb.ApplyStatus) storecontract.ApplyStatus {
|
|
if status == nil {
|
|
return storecontract.ApplyStatus{}
|
|
}
|
|
return storecontract.ApplyStatus{
|
|
Process: status.Process,
|
|
Kind: status.Kind,
|
|
AppliedVersion: status.AppliedVersion,
|
|
Error: status.Error,
|
|
ReportedAt: timeValue(status.ReportedAt),
|
|
}
|
|
}
|
|
|
|
func presenceProto(presence storecontract.Presence) *pb.Presence {
|
|
checks := make([]*pb.DependencyCheck, 0, len(presence.Checks))
|
|
for _, check := range presence.Checks {
|
|
checks = append(checks, &pb.DependencyCheck{Name: check.Name, Status: string(check.Status), Ready: check.Ready, Detail: check.Detail})
|
|
}
|
|
return &pb.Presence{
|
|
Service: presence.Service,
|
|
InstanceId: presence.InstanceID,
|
|
Version: presence.Version,
|
|
InstallType: presence.InstallType,
|
|
StartedAt: timestamp(presence.StartedAt),
|
|
ReportedAt: timestamp(presence.ReportedAt),
|
|
Ready: presence.Ready,
|
|
Detail: presence.Detail,
|
|
Checks: checks,
|
|
}
|
|
}
|
|
|
|
func presenceValue(presence *pb.Presence) storecontract.Presence {
|
|
if presence == nil {
|
|
return storecontract.Presence{}
|
|
}
|
|
checks := make([]health.Component, 0, len(presence.Checks))
|
|
for _, check := range presence.Checks {
|
|
checks = append(checks, health.Component{Name: check.Name, Status: health.Status(check.Status), Ready: check.Ready, Detail: check.Detail})
|
|
}
|
|
return storecontract.Presence{
|
|
Service: presence.Service,
|
|
InstanceID: presence.InstanceId,
|
|
Version: presence.Version,
|
|
InstallType: presence.InstallType,
|
|
StartedAt: timeValue(presence.StartedAt),
|
|
ReportedAt: timeValue(presence.ReportedAt),
|
|
Ready: presence.Ready,
|
|
Detail: presence.Detail,
|
|
Checks: checks,
|
|
}
|
|
}
|
|
|
|
// taskLogEntryProto and taskLogEntryValue mirror internal/logging.Entry, whose
|
|
// Fields map crosses as a JSON object string exactly as events.Event.Data does
|
|
// (see eventDataJSON above). The logging package owns that format end to end;
|
|
// this is a transport of it, not a second definition.
|
|
func taskLogEntryProto(e logging.Entry) *pb.TaskLogEntry {
|
|
return &pb.TaskLogEntry{
|
|
Id: e.ID, Time: timestamp(e.Time), Level: e.Level, Msg: e.Message,
|
|
FieldsJson: eventDataJSON(e.Fields),
|
|
}
|
|
}
|
|
|
|
func taskLogEntryValue(e *pb.TaskLogEntry) logging.Entry {
|
|
if e == nil {
|
|
return logging.Entry{}
|
|
}
|
|
return logging.Entry{
|
|
ID: e.Id, Time: timeValue(e.Time), Level: e.Level, Message: e.Msg,
|
|
Fields: eventDataValue(e.FieldsJson),
|
|
}
|
|
}
|
|
|
|
// taskLogRequestProto is the client half of the ReadTaskLog mapping and
|
|
// taskLogQueryValue the server half: the whole logging.Query crosses, not a
|
|
// subset of it, so a filter cannot silently stop working at the boundary.
|
|
func taskLogRequestProto(taskID int64, attempt int, q logging.Query) *pb.ReadTaskLogRequest {
|
|
return &pb.ReadTaskLogRequest{
|
|
TaskId: taskID, Attempt: int64(attempt), Limit: int64(q.Limit),
|
|
Levels: q.Levels, Component: q.Component, Stage: q.Stage, Contains: q.Contains,
|
|
Since: timestamp(q.Since), Until: timestamp(q.Until), BeforeId: q.BeforeID,
|
|
}
|
|
}
|
|
|
|
func taskLogQueryValue(r *pb.ReadTaskLogRequest) logging.Query {
|
|
return logging.Query{
|
|
Levels: r.Levels,
|
|
Component: r.Component,
|
|
Stage: r.Stage,
|
|
Contains: r.Contains,
|
|
Limit: int(r.Limit),
|
|
Since: timeValue(r.Since),
|
|
Until: timeValue(r.Until),
|
|
BeforeID: r.BeforeId,
|
|
}
|
|
}
|