Files
archipelago/sdk/guard/server.go
T

91 lines
3.1 KiB
Go

package guard
import (
"context"
"sync/atomic"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
guardv1 "github.com/samcharles93/archipelago/sdk/guard/v1"
)
// server adapts a Guard to the gRPC surface.
type server struct {
guardv1.UnimplementedGuardServiceServer
build func(Config) (Guard, error)
g atomic.Pointer[Guard]
}
func (s *server) Configure(_ context.Context, req *guardv1.ConfigureRequest) (*guardv1.ConfigureResponse, error) {
g, err := s.build(Config{Settings: req.GetSettings(), Secrets: req.GetSecrets()})
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, "configure: %v", err)
}
s.g.Store(&g)
return &guardv1.ConfigureResponse{}, nil
}
func (s *server) guard() (Guard, error) {
g := s.g.Load()
if g == nil {
return nil, status.Error(codes.FailedPrecondition, "guard not configured")
}
return *g, nil
}
func (s *server) Describe(context.Context, *guardv1.DescribeRequest) (*guardv1.DescribeResponse, error) {
g, err := s.guard()
if err != nil {
return nil, err
}
d := g.Describe()
return &guardv1.DescribeResponse{Contract: Contract, Name: d.Name, Version: d.Version, Advisory: d.Advisory}, nil
}
func (s *server) Judge(ctx context.Context, req *guardv1.JudgeRequest) (*guardv1.JudgeResponse, error) {
g, err := s.guard()
if err != nil {
return nil, err
}
if d := req.GetDeadline(); d != nil {
var cancel context.CancelFunc
ctx, cancel = context.WithTimeout(ctx, d.AsDuration())
defer cancel()
}
v, err := g.Judge(ctx, action(req))
if err != nil {
return nil, status.Errorf(codes.Unavailable, "judge: %v", err)
}
out := &guardv1.JudgeResponse{Ceiling: guardv1.Ceiling(v.Ceiling), BlindSpots: v.BlindSpots}
for _, f := range v.Findings {
out.Findings = append(out.Findings, &guardv1.Finding{Text: f.Text, Evidence: f.Evidence, Strength: guardv1.Strength(f.Strength)})
}
for _, j := range v.Judges {
out.Judges = append(out.Judges, &guardv1.JudgeRecord{
Model: j.Model, ResultId: j.ResultID, Answer: j.Answer, Confidence: j.Confidence, Reason: j.Reason,
Basis: j.Basis, BasisDigest: j.BasisDigest, Answers: j.Answers,
Trusted: j.Trusted, AdvisoryReason: j.AdvisoryReason, EvalDate: j.EvalDate,
Request: j.Request, Response: j.Response,
EndpointPath: j.EndpointPath, HttpStatus: int32(j.HTTPStatus), LatencyMs: j.LatencyMS,
})
}
return out, nil
}
func action(req *guardv1.JudgeRequest) Action {
t, e := req.GetTarget(), req.GetEffect()
evidence := make([]Evidence, 0, len(req.GetEvidence()))
for _, ev := range req.GetEvidence() {
evidence = append(evidence, Evidence{Source: ev.GetSource(), Text: ev.GetText()})
}
return Action{
Diagnosis: req.GetDiagnosis(), Evidence: evidence,
Connector: req.GetConnector(), Name: req.GetName(), Input: req.GetInput(), Digest: req.GetDigest(),
Target: Target{Kind: t.GetKind(), ID: t.GetId(), Environment: t.GetEnvironment(), Disposable: t.GetDisposable()},
Effect: Effect{ReadOnly: e.GetReadOnly(), Reversibility: int(e.GetReversibility()), Summary: e.GetSummary()},
RunID: req.GetRun().GetRunId(), DecisionKey: req.GetRun().GetDecisionKey(),
Deadline: req.GetDeadline().AsDuration(), At: req.GetAt().AsTime(),
}
}