173 lines
5.3 KiB
Go
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
|
|
}
|