mirror of
https://github.com/absmach/magistrala.git
synced 2026-06-23 04:10:28 +00:00
Dušan Borovčanin
94 lines
2.7 KiB
Go
94 lines
2.7 KiB
Go
// Copyright (c) Abstract Machines
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
package grpc
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
|
|
grpcCommonV1 "github.com/absmach/supermq/api/grpc/common/v1"
|
|
grpcGroupsV1 "github.com/absmach/supermq/api/grpc/groups/v1"
|
|
"github.com/absmach/supermq/pkg/errors"
|
|
svcerr "github.com/absmach/supermq/pkg/errors/service"
|
|
"github.com/go-kit/kit/endpoint"
|
|
kitgrpc "github.com/go-kit/kit/transport/grpc"
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
)
|
|
|
|
const svcName = "groups.v1.GroupsService"
|
|
|
|
var _ grpcGroupsV1.GroupsServiceClient = (*grpcClient)(nil)
|
|
|
|
type grpcClient struct {
|
|
timeout time.Duration
|
|
retrieveEntity endpoint.Endpoint
|
|
}
|
|
|
|
// NewClient returns new gRPC client instance.
|
|
func NewClient(conn *grpc.ClientConn, timeout time.Duration) grpcGroupsV1.GroupsServiceClient {
|
|
return &grpcClient{
|
|
retrieveEntity: kitgrpc.NewClient(
|
|
conn,
|
|
svcName,
|
|
"RetrieveEntity",
|
|
encodeRetrieveEntityRequest,
|
|
decodeRetrieveEntityResponse,
|
|
grpcCommonV1.RetrieveEntityRes{},
|
|
).Endpoint(),
|
|
|
|
timeout: timeout,
|
|
}
|
|
}
|
|
|
|
func (client grpcClient) RetrieveEntity(ctx context.Context, req *grpcCommonV1.RetrieveEntityReq, _ ...grpc.CallOption) (r *grpcCommonV1.RetrieveEntityRes, err error) {
|
|
ctx, cancel := context.WithTimeout(ctx, client.timeout)
|
|
defer cancel()
|
|
|
|
res, err := client.retrieveEntity(ctx, req)
|
|
if err != nil {
|
|
return &grpcCommonV1.RetrieveEntityRes{}, decodeError(err)
|
|
}
|
|
typedRes := res.(*grpcCommonV1.RetrieveEntityRes)
|
|
|
|
return typedRes, nil
|
|
}
|
|
|
|
func encodeRetrieveEntityRequest(_ context.Context, grpcReq any) (any, error) {
|
|
return grpcReq, nil
|
|
}
|
|
|
|
func decodeRetrieveEntityResponse(_ context.Context, grpcRes any) (any, error) {
|
|
return grpcRes, nil
|
|
}
|
|
|
|
func decodeError(err error) error {
|
|
if st, ok := status.FromError(err); ok {
|
|
switch st.Code() {
|
|
case codes.Unauthenticated:
|
|
return errors.Wrap(svcerr.ErrAuthentication, errors.New(st.Message()))
|
|
case codes.PermissionDenied:
|
|
return errors.Wrap(svcerr.ErrAuthorization, errors.New(st.Message()))
|
|
case codes.InvalidArgument:
|
|
return errors.Wrap(errors.ErrMalformedEntity, errors.New(st.Message()))
|
|
case codes.FailedPrecondition:
|
|
return errors.Wrap(errors.ErrMalformedEntity, errors.New(st.Message()))
|
|
case codes.NotFound:
|
|
return errors.Wrap(svcerr.ErrNotFound, errors.New(st.Message()))
|
|
case codes.AlreadyExists:
|
|
return errors.Wrap(svcerr.ErrConflict, errors.New(st.Message()))
|
|
case codes.OK:
|
|
if msg := st.Message(); msg != "" {
|
|
return errors.Wrap(errors.ErrUnidentified, errors.New(msg))
|
|
}
|
|
return nil
|
|
default:
|
|
return errors.Wrap(fmt.Errorf("unexpected gRPC status: %s (status code:%v)", st.Code().String(), st.Code()), errors.New(st.Message()))
|
|
}
|
|
}
|
|
return err
|
|
}
|