Files

173 lines
5.3 KiB
Go

package connector
import (
"context"
"sync/atomic"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"google.golang.org/protobuf/types/known/timestamppb"
connectorv1 "github.com/samcharles93/archipelago/sdk/connector/v1"
)
// server adapts a Connector to the gRPC surface. A capability the connector
// doesn't implement answers UNIMPLEMENTED.
type server struct {
connectorv1.UnimplementedConnectorServiceServer
build func(Config) (Connector, error)
c atomic.Pointer[Connector]
}
func (s *server) Configure(_ context.Context, req *connectorv1.ConfigureRequest) (*connectorv1.ConfigureResponse, error) {
c, err := s.build(Config{Settings: req.GetSettings(), Secrets: req.GetSecrets()})
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, "configure: %v", err)
}
s.c.Store(&c)
return &connectorv1.ConfigureResponse{}, nil
}
func (s *server) connector() (Connector, error) {
c := s.c.Load()
if c == nil {
return nil, status.Error(codes.FailedPrecondition, "connector not configured")
}
return *c, nil
}
func (s *server) Describe(context.Context, *connectorv1.DescribeRequest) (*connectorv1.DescribeResponse, error) {
c, err := s.connector()
if err != nil {
return nil, err
}
d := c.Describe()
_, listens := c.(Listener)
return &connectorv1.DescribeResponse{
Contract: Contract, Events: d.Events, Actions: d.Actions, Lookups: d.Lookups,
Deliveries: d.Deliveries, Listens: listens,
}, nil
}
func (s *server) Parse(ctx context.Context, req *connectorv1.ParseRequest) (*connectorv1.ParseResponse, error) {
c, err := s.connector()
if err != nil {
return nil, err
}
p, ok := c.(Parser)
if !ok {
return nil, status.Error(codes.Unimplemented, "connector hears no payloads")
}
events, err := p.Parse(ctx, req.GetBody(), req.GetHeaders())
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, "parse: %v", err)
}
return &connectorv1.ParseResponse{Events: wireEvents(events)}, nil
}
func wireEvents(events []Event) []*connectorv1.Event {
out := make([]*connectorv1.Event, 0, len(events))
for _, e := range events {
out = append(out, &connectorv1.Event{
Type: e.Type, SourceEventId: e.SourceEventID, Fields: e.Fields,
LinkKey: e.LinkKey, OccurredAt: timestamppb.New(e.OccurredAt),
})
}
return out
}
// Deliver sends one delivery.
func (s *server) Deliver(ctx context.Context, req *connectorv1.DeliverRequest) (*connectorv1.DeliverResponse, error) {
c, err := s.connector()
if err != nil {
return nil, err
}
d, ok := c.(Deliverer)
if !ok {
return nil, status.Error(codes.Unimplemented, "connector has no deliveries")
}
id, err := d.Deliver(ctx, req.GetDelivery(), req.GetInput(), req.GetIdempotencyKey())
if err != nil {
if IsPermanent(err) {
return nil, status.Errorf(codes.FailedPrecondition, "deliver: %v", err)
}
return nil, status.Errorf(codes.Unknown, "deliver: %v", err)
}
return &connectorv1.DeliverResponse{ExternalId: id}, nil
}
// Listen streams a listening connector's events until the host hangs up.
func (s *server) Listen(req *connectorv1.ListenRequest, stream connectorv1.ConnectorService_ListenServer) error {
c, err := s.connector()
if err != nil {
return err
}
l, ok := c.(Listener)
if !ok {
return status.Error(codes.Unimplemented, "connector doesn't listen")
}
err = l.Listen(stream.Context(), req.GetCursor(), func(events []Event, cursor string) error {
return stream.Send(&connectorv1.ListenResponse{Events: wireEvents(events), Cursor: cursor})
})
if err != nil && stream.Context().Err() == nil {
return status.Errorf(codes.Unavailable, "listen: %v", err)
}
return nil
}
func (s *server) actor() (Actor, error) {
c, err := s.connector()
if err != nil {
return nil, err
}
a, ok := c.(Actor)
if !ok {
return nil, status.Error(codes.Unimplemented, "connector has no actions")
}
return a, nil
}
func (s *server) Resolve(ctx context.Context, req *connectorv1.ResolveRequest) (*connectorv1.ResolveResponse, error) {
a, err := s.actor()
if err != nil {
return nil, err
}
return a.Resolve(ctx, req.GetAction(), req.GetInput())
}
// Invoke runs the action and reports the digest of the input it ran, so the
// host can check it ran the judged action. An action that may have taken
// effect is reported as an unknown outcome, with what went wrong as its
// output, never as an error: the host must not treat it as not having run.
func (s *server) Invoke(ctx context.Context, req *connectorv1.InvokeRequest) (*connectorv1.InvokeResponse, error) {
a, err := s.actor()
if err != nil {
return nil, err
}
out, unknown, err := a.Invoke(ctx, req.GetAction(), req.GetInput(), req.GetIdempotencyKey())
if err != nil && unknown {
out = []byte(err.Error())
} else if err != nil {
return nil, status.Errorf(codes.Unknown, "invoke: %v", err)
}
return &connectorv1.InvokeResponse{
Output: out, ExecutedDigest: Digest(req.GetAction(), req.GetInput()), OutcomeUnknown: unknown,
}, nil
}
func (s *server) Lookup(ctx context.Context, req *connectorv1.LookupRequest) (*connectorv1.LookupResponse, error) {
c, err := s.connector()
if err != nil {
return nil, err
}
l, ok := c.(Looker)
if !ok {
return nil, status.Error(codes.Unimplemented, "connector has no lookups")
}
out, found, err := l.Lookup(ctx, req.GetLookup(), req.GetInput())
if err != nil {
return nil, status.Errorf(codes.Unknown, "lookup: %v", err)
}
return &connectorv1.LookupResponse{Output: out, Found: found}, nil
}