Files
archie/internal/infrastructure/gatewayrpc/catalog.go
T

179 lines
5.8 KiB
Go

package gatewayrpc
import (
"context"
"time"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
pb "github.com/samcharles93/archie-core/internal/contracts/gateway/v1"
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/logging"
"github.com/samcharles93/archie-core/internal/secret"
)
// SkillEntry is one catalogued skill as the Skills page shows it: what it does
// and where it was discovered.
type SkillEntry struct {
Name string
Description string
Workflow string
Source string
}
// CuratorState is one registered curator's observable state: identity, health
// and recent activity. HasActivity is false for a curator that has never run.
type CuratorState struct {
Name string
HealthStatus string
HealthMessage string
HasActivity bool
LastRunAt time.Time
LastRunActions int
Recent []CuratorAction
}
// CuratorAction is one recorded curator action.
type CuratorAction struct {
At time.Time
Type string
Detail string
Reason string
}
// Catalog supplies the process-owned runtime surfaces the dashboard reads over
// ChatService. A zero Catalog answers empty lists and an Unavailable reload,
// which is the honest answer from a process that hosts none of them.
type Catalog struct {
CheckSecret func(secret.SecretRef) bool
Logs func(context.Context, string, logging.Query) (logging.Result, error)
Skills func() []SkillEntry
Curators func(context.Context) []CuratorState
ReloadChannel func(context.Context, string) error
}
// CatalogClient is the subset of the Gateway client the dashboard's catalog
// surfaces consume.
type CatalogClient interface {
CheckSecret(context.Context, secret.SecretRef) (bool, error)
ListSkills(ctx context.Context) ([]SkillEntry, error)
CuratorHealth(ctx context.Context) ([]CuratorState, error)
ReloadChannel(ctx context.Context, id string) error
}
var _ CatalogClient = (*Client)(nil)
func (s *server) CheckSecret(ctx context.Context, r *pb.CheckSecretRequest) (*pb.CheckSecretResponse, error) {
if p, ok := access.PrincipalFromContext(ctx); ok && !p.InstanceAdmin() {
return nil, status.Error(codes.PermissionDenied, "instance administrator required")
}
if r.Engine == "" || r.Key == "" {
return nil, status.Error(codes.InvalidArgument, "engine and key are required")
}
if s.catalog.CheckSecret == nil {
return nil, status.Error(codes.Unavailable, "secret resolution unavailable")
}
return &pb.CheckSecretResponse{Resolved: s.catalog.CheckSecret(secret.SecretRef{Engine: r.Engine, Key: r.Key})}, nil
}
func (c *Client) CheckSecret(ctx context.Context, ref secret.SecretRef) (bool, error) {
result, err := c.client.CheckSecret(ctx, &pb.CheckSecretRequest{Engine: ref.Engine, Key: ref.Key})
if err != nil {
return false, err
}
return result.Resolved, nil
}
func (s *server) ListSkills(_ context.Context, _ *pb.ListSkillsRequest) (*pb.ListSkillsResponse, error) {
if s.catalog.Skills == nil {
return &pb.ListSkillsResponse{}, nil
}
entries := s.catalog.Skills()
out := make([]*pb.Skill, 0, len(entries))
for _, e := range entries {
out = append(out, &pb.Skill{
Name: e.Name, Description: e.Description, Workflow: e.Workflow, Source: e.Source,
})
}
return &pb.ListSkillsResponse{Skills: out}, nil
}
func (s *server) CuratorHealth(ctx context.Context, _ *pb.CuratorHealthRequest) (*pb.CuratorHealthResponse, error) {
if s.catalog.Curators == nil {
return &pb.CuratorHealthResponse{}, nil
}
states := s.catalog.Curators(ctx)
out := make([]*pb.Curator, 0, len(states))
for _, st := range states {
curator := &pb.Curator{
Name: st.Name,
HealthStatus: st.HealthStatus,
HealthMessage: st.HealthMessage,
LastRunActions: int64(st.LastRunActions),
}
if st.HasActivity {
curator.LastRunAt = timestamp(st.LastRunAt)
}
for _, a := range st.Recent {
curator.RecentActions = append(curator.RecentActions, &pb.CuratorAction{
At: timestamp(a.At), Type: a.Type, Detail: a.Detail, Reason: a.Reason,
})
}
out = append(out, curator)
}
return &pb.CuratorHealthResponse{Curators: out}, nil
}
func (s *server) ReloadChannel(ctx context.Context, r *pb.ReloadChannelRequest) (*pb.ReloadChannelResponse, error) {
if s.catalog.ReloadChannel == nil {
return nil, status.Error(codes.Unavailable, "this gateway hosts no channels")
}
if err := s.catalog.ReloadChannel(ctx, r.ChannelId); err != nil {
return nil, err
}
return &pb.ReloadChannelResponse{}, nil
}
func (c *Client) ListSkills(ctx context.Context) ([]SkillEntry, error) {
v, err := c.client.ListSkills(ctx, &pb.ListSkillsRequest{})
if err != nil {
return nil, err
}
out := make([]SkillEntry, 0, len(v.Skills))
for _, s := range v.Skills {
out = append(out, SkillEntry{Name: s.Name, Description: s.Description, Workflow: s.Workflow, Source: s.Source})
}
return out, nil
}
func (c *Client) CuratorHealth(ctx context.Context) ([]CuratorState, error) {
v, err := c.client.CuratorHealth(ctx, &pb.CuratorHealthRequest{})
if err != nil {
return nil, err
}
out := make([]CuratorState, 0, len(v.Curators))
for _, curator := range v.Curators {
state := CuratorState{
Name: curator.Name,
HealthStatus: curator.HealthStatus,
HealthMessage: curator.HealthMessage,
LastRunActions: int(curator.LastRunActions),
}
if curator.LastRunAt != nil {
state.HasActivity = true
state.LastRunAt = curator.LastRunAt.AsTime()
}
for _, a := range curator.RecentActions {
state.Recent = append(state.Recent, CuratorAction{At: timeValue(a.At), Type: a.Type, Detail: a.Detail, Reason: a.Reason})
}
out = append(out, state)
}
return out, nil
}
func (c *Client) ReloadChannel(ctx context.Context, id string) error {
_, err := c.client.ReloadChannel(ctx, &pb.ReloadChannelRequest{ChannelId: id})
return err
}