grpcservermdl.go

package routebuildermdl

import (
	"context"
	"encoding/json"
	"net"

	"google.golang.org/grpc"

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/authmdl/jwtmdl"
	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/authmdl/roleenforcemdl"
	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/errormdl"
	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/grpcbuildermdl"
	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/loggermdl"
	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/servicebuildermdl"
)

// Server server
type Server struct{}

// GRPCInit init
func GRPCInit(GRPCPort net.Listener) {
	loggermdl.LogInfo("In GRPCInit")
	maxMsgSize := 50 * 1024 * 1024
	s := grpc.NewServer(grpc.MaxRecvMsgSize(maxMsgSize), grpc.MaxSendMsgSize(maxMsgSize))
	grpcbuildermdl.RegisterGRPCCheckServer(s, &Server{})
	grpcbuildermdl.RegisterGRPCServiceServer(s, &Server{})
	if err := s.Serve(GRPCPort); err != nil {
		loggermdl.LogError("Unable to start GRPC server: %v", err)
	}
	loggermdl.LogError("GRPC server started on :", GRPCPort.Addr().String())
}

// GRPCHandler GRPCHandler
func (*Server) GRPCHandler(ctx context.Context, req *grpcbuildermdl.GRPCRequest) (*grpcbuildermdl.GRPCByteResponse, error) {
	loggermdl.LogError("GRPC Handler inoked:")
	principal := servicebuildermdl.Principal{}
	errExecutingActivity := ""
	if req.GetGrpcMessage().GetIsRestricted() {
		claim, _ := jwtmdl.GeneratePricipleObjUsingToken(req.GetGrpcMessage().GetToken(), jwtmdl.GlobalJWTKey)
		groups, grperr := roleenforcemdl.GetGroupNames(claim, "groups")
		if errormdl.CheckErr(grperr) != nil {
			loggermdl.LogError("Error accessing group", grperr)
			return nil, errormdl.CheckErr(grperr)
		}
		userID, ok := claim["userId"].(string)
		if !ok || len(userID) < 2 {
			loggermdl.LogError("Unable to parse UserID from JWT Token")
			return nil, errormdl.Wrap("Unable to parse UserID from JWT Token")
		}
		rawMetadata, ok := claim["metadata"]
		if ok {
			metadata, ok := rawMetadata.(string)
			if !ok {
				loggermdl.LogError("Unable to parse metadata from JWT Token")
				return nil, errormdl.Wrap("Unable to parse metadata from JWT Token")
			}
			principal.Metadata = metadata
		}
		principal.Groups = groups
		principal.UserID = userID
		principal.Token = req.GetGrpcMessage().GetToken()
	}

	//TODO: call executeServiveBranchWise

	// result, _, _, errorCode, err := executeService(
	// 	req.GetGrpcMessage().GetName(),
	// 	req.GetGrpcMessage().GetData(), req.GetGrpcMessage().GetIsRestricted(),
	// 	req.GetGrpcMessage().GetIsRoleBased(), false, principal)
	result, _, _, errorCode, err := executeServiceWithBranch(
		req.GetGrpcMessage().GetName(),
		req.GetGrpcMessage().GetBranch(),
		req.GetGrpcMessage().GetData(),
		req.GetGrpcMessage().GetIsRestricted(),
		req.GetGrpcMessage().GetIsRoleBased(), false, principal)

	e, _ := json.Marshal(result)
	if err != nil {
		errExecutingActivity = err.Error()
	}
	res := &grpcbuildermdl.GRPCByteResponse{
		Data:      e,
		ErrorCode: int32(errorCode),
		Error:     errExecutingActivity,
	}
	return res, nil
}

// GRPCCheck GRPCCheck
func (*Server) GRPCCheck(ctx context.Context, req *grpcbuildermdl.GRPCRequest) (*grpcbuildermdl.GRPCResponse, error) {
	claim, _ := jwtmdl.GeneratePricipleObjUsingToken(req.GetGrpcMessage().GetToken(), jwtmdl.GlobalJWTKey)
	principal := servicebuildermdl.Principal{}
	groups, grperr := roleenforcemdl.GetGroupNames(claim, "groups")
	if errormdl.CheckErr(grperr) != nil {
		loggermdl.LogError(grperr)
		return nil, errormdl.CheckErr(grperr)
	}
	userID, ok := claim["userId"].(string)
	if !ok || len(userID) < 2 {
		loggermdl.LogError("Unable to parse UserID from JWT Token")
		return nil, errormdl.Wrap("Unable to parse UserID from JWT Token")
	}
	rawMetadata, ok := claim["metadata"]
	if ok {
		metadata, ok := rawMetadata.(string)
		if !ok {
			loggermdl.LogError("Unable to parse metadata from JWT Token")
			return nil, errormdl.Wrap("Unable to parse metadata from JWT Token")
		}
		principal.Metadata = metadata
	}
	principal.Groups = groups
	principal.UserID = userID
	principal.Token = req.GetGrpcMessage().GetToken()

	//TODO: remove logger
	loggermdl.LogError("Branch:", req.GetGrpcMessage().GetBranch())
	_, _, _, _, err := executeServiceWithBranch(
		req.GetGrpcMessage().GetName(),
		req.GetGrpcMessage().GetBranch(),
		req.GetGrpcMessage().GetData(),
		req.GetGrpcMessage().GetIsRestricted(),
		req.GetGrpcMessage().GetIsRoleBased(), false, principal)

	// _, _, _, _, err := executeService(
	// 	req.GetGrpcMessage().GetName(),
	// 	req.GetGrpcMessage().GetData(),
	// 	req.GetGrpcMessage().GetIsRestricted(),
	// 	req.GetGrpcMessage().GetIsRoleBased(), false, principal)
	res := &grpcbuildermdl.GRPCResponse{
		Data: "Response from GRPC Check service",
	}
	return res, err
}