grpcclientmdl.go

package grpcclientmdl

import (
	"context"
	"errors"
	"time"

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/grpcbuildermdl"
	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/loggermdl"
	grpcpool "github.com/processout/grpc-go-pool"
	"google.golang.org/grpc"
)

// TotalCheck TotalCheck
func TotalCheck() (string, error) {
	// TODO: review
	conn, err := grpc.Dial("0.0.0.0:50051", grpc.WithInsecure())
	if err != nil {
		loggermdl.LogError("Could not connect: ", err)
	}
	defer conn.Close()
	c := grpcbuildermdl.NewGRPCCheckClient(conn)

	req := &grpcbuildermdl.GRPCRequest{}
	res, err := c.GRPCCheck(context.Background(), req)

	return res.GetData(), nil
}

var instances = make(map[string]*grpcpool.Pool)
var instancesList map[string]map[string]*grpcpool.Pool

// Init init
func Init(grpcServerURLList []string, grpcClients []string) {
	// instances = make(map[string]*grpcpool.Pool)
	loggermdl.LogError("Length of grpcServerURLList", len(grpcServerURLList))

	for index := 0; index < len(grpcServerURLList); index++ {
		CreateConnection(grpcServerURLList[index], grpcClients[index])
	}
	loggermdl.LogError("instances", instances)
}

//ByteHandler ByteHandler
func ByteHandler(req *grpcbuildermdl.GRPCRequest, grpcServerURL string) ([]byte, int32, string, error) {
	if instances[grpcServerURL] != nil {
		conn, err := instances[grpcServerURL].Get(context.Background())
		if err != nil {
			loggermdl.LogError("Failed to create gRPC pool: %v", err)
			return nil, 0, "", err
		}
		defer conn.Close()
		client := grpcbuildermdl.NewGRPCServiceClient(conn.ClientConn)
		res, err := client.GRPCHandler(context.Background(), req)
		if err != nil {
			loggermdl.LogError("GRPCHandler err:", res.GetError())
			return res.GetData(), res.GetErrorCode(), res.GetError(), err
		}
		return res.GetData(), res.GetErrorCode(), res.GetError(), nil
	}
	return nil, 0, "", errors.New("no grpc connection found")
}

// CreateConnection method
func CreateConnection(serverURL string, grpcClientName string) {
	var factory grpcpool.Factory
	factory = func() (*grpc.ClientConn, error) {
		maxMsgSize := 50 * 1024 * 1024
		conn, err := grpc.Dial(
			serverURL,
			grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(maxMsgSize), grpc.MaxCallSendMsgSize(maxMsgSize)),
			grpc.WithInsecure(),
		)
		if err != nil {
			loggermdl.LogError("Failed to start gRPC connection: %v", err)
		}
		return conn, err
	}
	pool, err := grpcpool.New(factory, 5, 5, time.Second)
	if err != nil {
		loggermdl.LogError("Failed to create gRPC pool: %v", err)
	}
	instances[grpcClientName] = pool
}