Files
archie/internal/infrastructure/staterpc/captures.go
T

171 lines
5.7 KiB
Go

package staterpc
import (
"context"
"errors"
"io"
"time"
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
)
type captureServer struct {
pb.UnimplementedCaptureServiceServer
*server
}
func (s *server) capture() (storecontract.CaptureStore, error) {
if s.deps.Captures == nil {
return nil, errCaptureUnavailable
}
return s.deps.Captures, nil
}
func (s *captureServer) RecordCaptureRefusal(ctx context.Context, r *pb.RecordCaptureRefusalRequest) (*pb.RecordCaptureRefusalResponse, error) {
if s.deps.Refusals == nil {
return nil, errRefusalsUnavailable
}
if err := s.deps.Refusals.RecordCaptureRefusal(ctx, r.Source, r.Addr, timeValue(r.RefusedAt)); err != nil {
return nil, s.logErr("RecordCaptureRefusal", err)
}
return &pb.RecordCaptureRefusalResponse{}, nil
}
func (s *captureServer) ListCaptureRefusals(ctx context.Context, r *pb.ListCaptureRefusalsRequest) (*pb.ListCaptureRefusalsResponse, error) {
if s.deps.Refusals == nil {
return nil, errRefusalsUnavailable
}
sources, err := s.deps.Refusals.CaptureRefusals(ctx, timeValue(r.Since))
if err != nil {
return nil, s.logErr("ListCaptureRefusals", err)
}
out := make([]*pb.CaptureRefusals, 0, len(sources))
for _, c := range sources {
out = append(out, &pb.CaptureRefusals{Source: c.Source, Refused: c.Refused, Accepted: c.Accepted, Addrs: c.Addrs})
}
return &pb.ListCaptureRefusalsResponse{Sources: out}, nil
}
func (s *captureServer) InsertCapture(ctx context.Context, r *pb.InsertCaptureRequest) (*pb.InsertCaptureResponse, error) {
cs, err := s.capture()
if err != nil {
return nil, err
}
id, err := cs.InsertCapture(ctx, capturedEventValue(r.Capture), timeSeconds(r.RetentionSeconds), int(r.MaxEvents))
if err != nil {
return nil, s.logErr("InsertCapture", err)
}
return &pb.InsertCaptureResponse{Id: id}, nil
}
// StreamCaptures streams one capture per message: a batch of large capture
// bodies in one unary response can exceed gRPC's 4MiB message cap
func (s *captureServer) StreamCaptures(r *pb.StreamCapturesRequest, stream pb.CaptureService_StreamCapturesServer) error {
cs, err := s.capture()
if err != nil {
return err
}
captures, err := cs.ListCaptures(stream.Context(), int(r.Limit))
if err != nil {
return s.logErr("StreamCaptures", err)
}
for _, c := range captures {
if err := stream.Send(&pb.StreamCapturesResponse{Capture: capturedEventProto(c)}); err != nil {
return err
}
}
return nil
}
// Mapping
// StreamUndispatchedCaptures streams for the same reason as StreamCaptures.
func (s *captureServer) StreamUndispatchedCaptures(r *pb.StreamUndispatchedCapturesRequest, stream pb.CaptureService_StreamUndispatchedCapturesServer) error {
if s.deps.BindingDispatcher == nil {
return errBindingDispatchUnavailable
}
captures, err := s.deps.BindingDispatcher.ListUndispatchedCaptures(stream.Context(), r.Bindings, int(r.Limit))
if err != nil {
return s.logErr("StreamUndispatchedCaptures", err)
}
for _, c := range captures {
if err := stream.Send(&pb.StreamUndispatchedCapturesResponse{Capture: capturedEventProto(c)}); err != nil {
return err
}
}
return nil
}
// BindingTaskCreator
func (c *Client) InsertCapture(ctx context.Context, ce storecontract.CapturedEvent, retention time.Duration, maxEvents int) (string, error) {
r, err := c.capture.InsertCapture(ctx, &pb.InsertCaptureRequest{Capture: capturedEventProto(ce), RetentionSeconds: int64(retention.Seconds()), MaxEvents: int64(maxEvents)})
if err != nil {
return "", unmapError(err)
}
return r.Id, nil
}
// RecordCaptureRefusal counts one event the network rules refused.
func (c *Client) RecordCaptureRefusal(ctx context.Context, source, addr string, at time.Time) error {
_, err := c.capture.RecordCaptureRefusal(ctx, &pb.RecordCaptureRefusalRequest{Source: source, Addr: addr, RefusedAt: timestamp(at)})
return unmapError(err)
}
// CaptureRefusals reads each source's refusals since a time.
func (c *Client) CaptureRefusals(ctx context.Context, since time.Time) ([]storecontract.CaptureRefusals, error) {
reply, err := c.capture.ListCaptureRefusals(ctx, &pb.ListCaptureRefusalsRequest{Since: timestamp(since)})
if err != nil {
return nil, unmapError(err)
}
out := make([]storecontract.CaptureRefusals, 0, len(reply.Sources))
for _, s := range reply.Sources {
out = append(out, storecontract.CaptureRefusals{Source: s.Source, Refused: s.Refused, Accepted: s.Accepted, Addrs: s.Addrs})
}
return out, 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.capture.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
// ListUndispatchedCaptures streams for the same reason as ListCaptures.
func (c *Client) ListUndispatchedCaptures(ctx context.Context, bindings []string, limit int) ([]storecontract.CapturedEvent, error) {
stream, err := c.capture.StreamUndispatchedCaptures(ctx, &pb.StreamUndispatchedCapturesRequest{Bindings: bindings, 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