171 lines
5.7 KiB
Go
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
|