First iteration of selfpass gRPC backend, w/ credentials CRUD functional

credentials/transport/encoding.go

@@ -0,0 +1,127 @@
+package transport
+
+import (
+	"context"
+
+	"github.com/golang/protobuf/ptypes"
+	"github.com/mitchell/selfpass/credentials/endpoints"
+	"github.com/mitchell/selfpass/credentials/protobuf"
+	"github.com/mitchell/selfpass/credentials/types"
+)
+
+func decodeGetAllMetadataRequest(ctx context.Context, request interface{}) (interface{}, error) {
+	r := request.(protobuf.GetAllMetadataRequest)
+	return endpoints.GetAllMetadataRequest{
+		SourceHost: r.SourceHost,
+	}, nil
+}
+
+func encodeMetadataStreamResponse(ctx context.Context, response interface{}) (interface{}, error) {
+	r := response.(endpoints.MetadataStream)
+	pbmdch := make(chan protobuf.Metadata, 1)
+
+	go func() {
+		defer close(pbmdch)
+
+		for md := range r.Metadata {
+			createdAt, err := ptypes.TimestampProto(md.CreatedAt)
+			if err != nil {
+				r.Errors <- err
+				return
+			}
+
+			updatedAt, err := ptypes.TimestampProto(md.UpdatedAt)
+			if err != nil {
+				r.Errors <- err
+				return
+			}
+
+			pbmdch <- protobuf.Metadata{
+				Id:         md.ID,
+				CreatedAt:  createdAt,
+				UpdatedAt:  updatedAt,
+				SourceHost: md.SourceHost,
+				Primary:    md.Primary,
+				LoginUrl:   md.LoginURL,
+			}
+		}
+	}()
+
+	return protobufMetadataStream{
+		Metadata: pbmdch,
+		Errors:   r.Errors,
+	}, nil
+}
+
+type protobufMetadataStream struct {
+	Metadata <-chan protobuf.Metadata
+	Errors   chan error
+}
+
+func decodeCredentialRequest(ctx context.Context, request interface{}) (interface{}, error) {
+	r := request.(protobuf.CredentialRequest)
+	return types.CredentialInput{
+		MetadataInput: types.MetadataInput{
+			Primary:    r.Primary,
+			LoginURL:   r.LoginUrl,
+			SourceHost: r.SourceHost,
+		},
+		Username: r.Username,
+		Email:    r.Email,
+		Password: r.Password,
+	}, nil
+}
+
+func encodeCredentialResponse(ctx context.Context, response interface{}) (interface{}, error) {
+	r := response.(types.Credential)
+
+	createdAt, err := ptypes.TimestampProto(r.CreatedAt)
+	if err != nil {
+		return nil, err
+	}
+
+	updatedAt, err := ptypes.TimestampProto(r.UpdatedAt)
+	if err != nil {
+		return nil, err
+	}
+
+	return protobuf.Credential{
+		Id:         r.ID,
+		CreatedAt:  createdAt,
+		UpdatedAt:  updatedAt,
+		Primary:    r.Primary,
+		SourceHost: r.SourceHost,
+		LoginUrl:   r.LoginURL,
+		Username:   r.Username,
+		Email:      r.Email,
+		Password:   r.Password,
+	}, nil
+}
+
+func decodeUpdateRequest(ctx context.Context, request interface{}) (interface{}, error) {
+	r := request.(protobuf.UpdateRequest)
+	return endpoints.UpdateRequest{
+		ID: r.Id,
+		Credential: types.CredentialInput{
+			MetadataInput: types.MetadataInput{
+				Primary:    r.Credential.Primary,
+				SourceHost: r.Credential.SourceHost,
+				LoginURL:   r.Credential.LoginUrl,
+			},
+			Username: r.Credential.Username,
+			Email:    r.Credential.Email,
+			Password: r.Credential.Password,
+		},
+	}, nil
+}
+
+func decodeIdRequest(ctx context.Context, request interface{}) (interface{}, error) {
+	r := request.(protobuf.IdRequest)
+	return endpoints.IDRequest{
+		ID: r.Id,
+	}, nil
+}
+
+func noOpEncode(ctx context.Context, request interface{}) (interface{}, error) {
+	return nil, nil
+}

credentials/transport/grpc_server.go

@@ -0,0 +1,146 @@
+package transport
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/go-kit/kit/log"
+	"github.com/go-kit/kit/transport/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"github.com/mitchell/selfpass/credentials/endpoints"
+	"github.com/mitchell/selfpass/credentials/protobuf"
+	"github.com/mitchell/selfpass/credentials/types"
+)
+
+// NewGRPCServer TODO
+func NewGRPCServer(svc types.Service, logger log.Logger) GRPCServer {
+	return GRPCServer{
+		getAllMetadata: grpc.NewServer(
+			endpoints.MakeGetAllMetadataEndpoint(svc),
+			decodeGetAllMetadataRequest,
+			encodeMetadataStreamResponse,
+			grpc.ServerErrorLogger(logger),
+		),
+		create: grpc.NewServer(
+			endpoints.MakeCreateEndpoint(svc),
+			decodeCredentialRequest,
+			encodeCredentialResponse,
+			grpc.ServerErrorLogger(logger),
+		),
+		update: grpc.NewServer(
+			endpoints.MakeUpdateEndpoint(svc),
+			decodeUpdateRequest,
+			encodeCredentialResponse,
+			grpc.ServerErrorLogger(logger),
+		),
+		delete: grpc.NewServer(
+			endpoints.MakeDeleteEndpoint(svc),
+			decodeIdRequest,
+			noOpEncode,
+			grpc.ServerErrorLogger(logger),
+		),
+	}
+}
+
+// GRPCServer TODO
+type GRPCServer struct {
+	getAllMetadata *grpc.Server
+	create         *grpc.Server
+	update         *grpc.Server
+	delete         *grpc.Server
+}
+
+// GetAllMetadata TODO
+func (s GRPCServer) GetAllMetadata(r *protobuf.GetAllMetadataRequest, srv protobuf.CredentialService_GetAllMetadataServer) (err error) {
+	defer func() {
+		err = handlerGRPCError(err)
+	}()
+
+	var i interface{}
+	ctx := srv.Context()
+
+	ctx, i, err = s.getAllMetadata.ServeGRPC(ctx, *r)
+	if err != nil {
+		return err
+	}
+
+	mds := i.(protobufMetadataStream)
+
+receiveLoop:
+	for {
+		select {
+		case <-ctx.Done():
+			break receiveLoop
+		case err = <-mds.Errors:
+			break receiveLoop
+		case md, ok := <-mds.Metadata:
+			if !ok {
+				break receiveLoop
+			}
+			fmt.Println(md)
+			if err = srv.Send(&md); err != nil {
+				break receiveLoop
+			}
+		}
+	}
+
+	return err
+}
+
+// Get TODO
+func (s GRPCServer) Get(context.Context, *protobuf.IdRequest) (*protobuf.Credential, error) {
+	panic("implement me")
+}
+
+// Create TODO
+func (s GRPCServer) Create(ctx context.Context, ci *protobuf.CredentialRequest) (*protobuf.Credential, error) {
+	ctx, i, err := s.create.ServeGRPC(ctx, *ci)
+	if err != nil {
+		err = handlerGRPCError(err)
+		return nil, err
+	}
+
+	c := &protobuf.Credential{}
+	*c = i.(protobuf.Credential)
+	return c, nil
+}
+
+// Update TODO
+func (s GRPCServer) Update(ctx context.Context, r *protobuf.UpdateRequest) (*protobuf.Credential, error) {
+	ctx, i, err := s.update.ServeGRPC(ctx, *r)
+	if err != nil {
+		err = handlerGRPCError(err)
+		return nil, err
+	}
+
+	c := &protobuf.Credential{}
+	*c = i.(protobuf.Credential)
+	return c, nil
+}
+
+// Delete TODO
+func (s GRPCServer) Delete(ctx context.Context, r *protobuf.IdRequest) (*protobuf.DeleteResponse, error) {
+	ctx, _, err := s.delete.ServeGRPC(ctx, *r)
+	if err != nil {
+		return nil, err
+	}
+
+	return &protobuf.DeleteResponse{Success: true}, nil
+}
+
+func handlerGRPCError(err error) error {
+	if err != nil {
+		switch {
+		case strings.HasPrefix(err.Error(), types.InvalidArgument):
+			err = status.Error(codes.InvalidArgument, err.Error())
+		case strings.HasPrefix(err.Error(), types.NotFound):
+			err = status.Error(codes.NotFound, err.Error())
+		default:
+			err = status.Error(codes.Internal, "an internal error has occurred")
+		}
+	}
+	return err
+}