github.com/abolfazlbeh/zhycan@v0.0.0-20230819144214-24cf38237387/internal/grpc/server_wrapper.go (about)

     1  package grpc
     2  
     3  import (
     4  	"fmt"
     5  	"github.com/abolfazlbeh/zhycan/internal/logger"
     6  	"google.golang.org/grpc"
     7  	"net"
     8  	"time"
     9  )
    10  
    11  // MARK: Variables
    12  
    13  var (
    14  	ServerMaintenanceType = logger.NewLogType("PROTOBUF_SERVER_MAINTENANCE")
    15  )
    16  
    17  // ServerWrapper struct
    18  type ServerWrapper struct {
    19  	name        string
    20  	grpcServer  *grpc.Server
    21  	listener    net.Listener
    22  	initialized bool
    23  	config      ServerConfig
    24  	//authObj     *auth.Authentication
    25  	//authEnable bool
    26  }
    27  
    28  // init - initialize the ServerWrapper with the configs
    29  func (s *ServerWrapper) init(name string, serverConfig ServerConfig) error {
    30  	s.name = name
    31  	s.initialized = false
    32  
    33  	s.config = serverConfig
    34  
    35  	lis, err := net.Listen(s.config.Protocol, fmt.Sprintf("%s:%d", s.config.Host, s.config.Port))
    36  	if err != nil {
    37  		return err
    38  	}
    39  
    40  	//authEnable, err := config.GetManager().Get(parts[0], parts[1]+".auth_enable")
    41  	//if err != nil {
    42  	//	return err
    43  	//}
    44  	//s.authEnable = authEnable.(bool)
    45  
    46  	//s.authObj = &auth.Authentication{}
    47  	//s.authObj.Init()
    48  
    49  	options := s.generateConfigs(s.config.Configs)
    50  
    51  	s.listener = lis
    52  	s.grpcServer = grpc.NewServer(options...)
    53  
    54  	s.initialized = true
    55  	return nil
    56  }
    57  
    58  // generateConfigs - generate grpc.ServerOption array from configs
    59  func (s *ServerWrapper) generateConfigs(configs map[string]interface{}) []grpc.ServerOption {
    60  	var options []grpc.ServerOption
    61  	if v, ok := configs["maxreceivemessagesize"]; ok {
    62  		options = append(options, grpc.MaxRecvMsgSize(v.(int)))
    63  	}
    64  
    65  	if v, ok := configs["maxsendmessagesize"]; ok {
    66  		options = append(options, grpc.MaxSendMsgSize(v.(int)))
    67  	}
    68  
    69  	return options
    70  }
    71  
    72  // MARK: Public functions
    73  
    74  // NewServer - create a new instance of Server and return it
    75  func NewServer(name string, config ServerConfig) (*ServerWrapper, error) {
    76  	server := &ServerWrapper{}
    77  	err := server.init(name, config)
    78  	if err != nil {
    79  		return nil, NewCreateServerErr(err)
    80  	}
    81  
    82  	return server, nil
    83  }
    84  
    85  // Start - start the server with option of async capability
    86  func (s *ServerWrapper) Start(ch *chan error) error {
    87  	l, _ := logger.GetManager().GetLogger()
    88  	if l != nil {
    89  		l.Log(logger.NewLogObject(logger.INFO, "protobuf.Server.Start", ServerMaintenanceType, time.Now(), "Starting the gRPC server ...", s.listener))
    90  	}
    91  
    92  	if s.config.Async {
    93  		go func(ch1 *chan error) {
    94  			err := s.grpcServer.Serve(s.listener)
    95  			if err != nil && ch1 != nil {
    96  				*ch <- NewGrpcServerStartError(err)
    97  			}
    98  		}(ch)
    99  	} else {
   100  		err := s.grpcServer.Serve(s.listener)
   101  		if err != nil {
   102  			return NewGrpcServerStartError(err)
   103  		}
   104  	}
   105  
   106  	return nil
   107  }
   108  
   109  // Stop - stop the server
   110  func (s *ServerWrapper) Stop() {
   111  	if s.grpcServer != nil {
   112  		s.grpcServer.Stop()
   113  	}
   114  }
   115  
   116  // IsInitialized - return whether the server is started or not
   117  func (s *ServerWrapper) IsInitialized() bool {
   118  	return s.initialized
   119  }
   120  
   121  func (s *ServerWrapper) RegisterController(f func(server *grpc.Server, cls interface{}), realClass interface{}) error {
   122  	if realClass != nil {
   123  		f(s.grpcServer, realClass)
   124  		return nil
   125  	}
   126  
   127  	return NewNilServiceRegistryError()
   128  }