91 lines
3.1 KiB
Go
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(),
|
|
}
|
|
}
|