1
0
mirror of https://github.com/mainflux/mainflux.git synced 2025-04-29 13:49:28 +08:00

116 lines
3.5 KiB
Go
Raw Normal View History

// Copyright (c) Mainflux
// SPDX-License-Identifier: Apache-2.0
2018-05-10 23:53:25 +02:00
package grpc
import (
"context"
2019-07-18 15:01:09 +02:00
kitot "github.com/go-kit/kit/tracing/opentracing"
2018-05-10 23:53:25 +02:00
kitgrpc "github.com/go-kit/kit/transport/grpc"
"github.com/golang/protobuf/ptypes/empty"
2018-05-10 23:53:25 +02:00
"github.com/mainflux/mainflux"
"github.com/mainflux/mainflux/things"
2019-07-18 15:01:09 +02:00
opentracing "github.com/opentracing/opentracing-go"
2018-05-10 23:53:25 +02:00
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
var _ mainflux.ThingsServiceServer = (*grpcServer)(nil)
2018-05-10 23:53:25 +02:00
type grpcServer struct {
canAccessByKey kitgrpc.Handler
canAccessByID kitgrpc.Handler
identify kitgrpc.Handler
2018-05-10 23:53:25 +02:00
}
// NewServer returns new ThingsServiceServer instance.
2019-07-18 15:01:09 +02:00
func NewServer(tracer opentracing.Tracer, svc things.Service) mainflux.ThingsServiceServer {
return &grpcServer{
canAccessByKey: kitgrpc.NewServer(
2019-07-18 15:01:09 +02:00
kitot.TraceServer(tracer, "can_access")(canAccessEndpoint(svc)),
decodeCanAccessByKeyRequest,
encodeIdentityResponse,
),
canAccessByID: kitgrpc.NewServer(
canAccessByIDEndpoint(svc),
decodeCanAccessByIDRequest,
encodeEmptyResponse,
),
identify: kitgrpc.NewServer(
2019-07-18 15:01:09 +02:00
kitot.TraceServer(tracer, "identify")(identifyEndpoint(svc)),
decodeIdentifyRequest,
encodeIdentityResponse,
),
}
2018-05-10 23:53:25 +02:00
}
func (gs *grpcServer) CanAccessByKey(ctx context.Context, req *mainflux.AccessByKeyReq) (*mainflux.ThingID, error) {
_, res, err := gs.canAccessByKey.ServeGRPC(ctx, req)
2018-05-10 23:53:25 +02:00
if err != nil {
return nil, encodeError(err)
}
return res.(*mainflux.ThingID), nil
}
func (gs *grpcServer) CanAccessByID(ctx context.Context, req *mainflux.AccessByIDReq) (*empty.Empty, error) {
_, res, err := gs.canAccessByID.ServeGRPC(ctx, req)
if err != nil {
return nil, encodeError(err)
}
return res.(*empty.Empty), nil
}
func (gs *grpcServer) Identify(ctx context.Context, req *mainflux.Token) (*mainflux.ThingID, error) {
_, res, err := gs.identify.ServeGRPC(ctx, req)
if err != nil {
return nil, encodeError(err)
}
return res.(*mainflux.ThingID), nil
2018-05-10 23:53:25 +02:00
}
func decodeCanAccessByKeyRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
req := grpcReq.(*mainflux.AccessByKeyReq)
return AccessByKeyReq{thingKey: req.GetToken(), chanID: req.GetChanID()}, nil
2018-05-10 23:53:25 +02:00
}
func decodeCanAccessByIDRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
req := grpcReq.(*mainflux.AccessByIDReq)
return accessByIDReq{thingID: req.GetThingID(), chanID: req.GetChanID()}, nil
}
func decodeIdentifyRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
req := grpcReq.(*mainflux.Token)
return identifyReq{key: req.GetValue()}, nil
}
func encodeIdentityResponse(_ context.Context, grpcRes interface{}) (interface{}, error) {
res := grpcRes.(identityRes)
return &mainflux.ThingID{Value: res.id}, nil
2018-05-10 23:53:25 +02:00
}
func encodeEmptyResponse(_ context.Context, grpcRes interface{}) (interface{}, error) {
res := grpcRes.(emptyRes)
return &empty.Empty{}, encodeError(res.err)
}
2018-05-10 23:53:25 +02:00
func encodeError(err error) error {
switch err {
case nil:
return nil
case things.ErrMalformedEntity:
2018-05-10 23:53:25 +02:00
return status.Error(codes.InvalidArgument, "received invalid can access request")
case things.ErrUnauthorizedAccess:
2018-05-14 13:11:29 +02:00
return status.Error(codes.PermissionDenied, "missing or invalid credentials provided")
case things.ErrEntityConnected:
return status.Error(codes.PermissionDenied, "entities are not connected")
case things.ErrNotFound:
return status.Error(codes.NotFound, "entity does not exist")
2018-05-10 23:53:25 +02:00
default:
return status.Error(codes.Internal, "internal server error")
}
}