@@ -28,6 +28,12 @@ type grpcServer struct {
2828 config config.Config
2929}
3030
31+ var (
32+ ErrNonAddressable = errors .New ("cannot inject container as it is not addressable or is nil" )
33+ ErrInvalidPort = errors .New ("invalid port number" )
34+ ErrFailedCreateServer = errors .New ("failed to create gRPC server" )
35+ )
36+
3137// AddGRPCServerOptions allows users to add custom gRPC server options such as TLS configuration,
3238// timeouts, interceptors, and other server-specific settings in a single call.
3339//
@@ -44,14 +50,15 @@ type grpcServer struct {
4450// to the server's configuration. It allows fine-tuning of the gRPC server's behavior during its initialization.
4551func (a * App ) AddGRPCServerOptions (grpcOpts ... grpc.ServerOption ) {
4652 if len (grpcOpts ) == 0 {
47- a .container .Logger .Debug ("no gRPC server options provided" )
48- return
49- }
53+ a .container .Logger .Debug ("no gRPC server options provided" )
54+ return
55+ }
56+
5057 a .container .Logger .Debugf ("adding %d gRPC server options" , len (grpcOpts ))
5158 a .grpcServer .options = append (a .grpcServer .options , grpcOpts ... )
5259}
5360
54- // AddGRPCUnaryInterceptors allows users to add custom gRPC interceptors.
61+ // AddGRPCUnaryInterceptors allows users to add custom gRPC interceptors.
5562// Example:
5663//
5764// func loggingInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo,
@@ -62,12 +69,12 @@ func (a *App) AddGRPCServerOptions(grpcOpts ...grpc.ServerOption) {
6269// app.AddGRPCUnaryInterceptors(loggingInterceptor)
6370func (a * App ) AddGRPCUnaryInterceptors (interceptors ... grpc.UnaryServerInterceptor ) {
6471 if len (interceptors ) == 0 {
65- a .container .Logger .Debug ("no unary interceptors provided" )
66- return
67- }
68-
72+ a .container .Logger .Debug ("no unary interceptors provided" )
73+ return
74+ }
75+
6976 a .container .Logger .Debugf ("adding %d valid unary interceptors" , len (interceptors ))
70- a .grpcServer .interceptors = append (a .grpcServer .interceptors , interceptors ... )
77+ a .grpcServer .interceptors = append (a .grpcServer .interceptors , interceptors ... )
7178}
7279
7380func (a * App ) AddGRPCServerStreamInterceptors (interceptors ... grpc.StreamServerInterceptor ) {
@@ -81,12 +88,12 @@ func (a *App) AddGRPCServerStreamInterceptors(interceptors ...grpc.StreamServerI
8188}
8289
8390func newGRPCServer (c * container.Container , port int , cfg config.Config ) (* grpcServer , error ) {
84- if port <= 0 || port > 65535 {
85- return nil , fmt .Errorf ("invalid port number : %d" , port )
86- }
91+ if port <= 0 || port > 65535 {
92+ return nil , fmt .Errorf ("%w : %d" , ErrInvalidPort , port )
93+ }
8794
8895 c .Logger .Infof ("creating new gRPC server on port %d" , port )
89-
96+
9097 registerGRPCMetrics (c )
9198
9299 middleware := make ([]grpc.UnaryServerInterceptor , 0 )
@@ -98,9 +105,9 @@ func newGRPCServer(c *container.Container, port int, cfg config.Config) (*grpcSe
98105 streamMiddleware = append (streamMiddleware ,
99106 grpc_recovery .StreamServerInterceptor (),
100107 gofr_grpc .StreamObservabilityInterceptor (c .Logger , c .Metrics ()))
101-
108+
102109 c .Logger .Debugf ("gRPC server created successfully on port %d" , port )
103-
110+
104111 return & grpcServer {
105112 port : port ,
106113 interceptors : middleware ,
@@ -109,62 +116,64 @@ func newGRPCServer(c *container.Container, port int, cfg config.Config) (*grpcSe
109116 }, nil
110117}
111118
112- // registerGRPCMetrics registers essential gRPC metrics
119+ // registerGRPCMetrics registers essential gRPC metrics.
113120func registerGRPCMetrics (c * container.Container ) {
114121 c .Metrics ().NewGauge ("grpc_server_status" , "gRPC server status (1=running, 0=stopped)" )
115122 c .Metrics ().NewCounter ("grpc_server_errors_total" , "Total gRPC server errors" )
116123 c .Metrics ().NewCounter ("grpc_services_registered_total" , "Total gRPC services registered" )
117124}
118125
119- func (g * grpcServer ) createServer () error {
126+ func (g * grpcServer ) createServer () error {
120127 interceptorOption := grpc .UnaryInterceptor (grpc_middleware .ChainUnaryServer (g .interceptors ... ))
121128 streamOpt := grpc .StreamInterceptor (grpc_middleware .ChainStreamServer (g .streamInterceptors ... ))
122129 g .options = append (g .options , interceptorOption , streamOpt )
123130
124131 g .server = grpc .NewServer (g .options ... )
125132 if g .server == nil {
126- return errors . New ( "failed to create gRPC server" )
127- }
133+ return ErrFailedCreateServer
134+ }
128135
129136 enabled := strings .ToLower (g .config .GetOrDefault ("GRPC_ENABLE_REFLECTION" , "false" ))
130- if enabled == "true" {
131- reflection .Register (g .server )
132- }
137+ if enabled == defaultTelemetry {
138+ reflection .Register (g .server )
139+ }
133140
134141 return nil
135142}
136143
137144func (g * grpcServer ) Run (c * container.Container ) {
138-
139145 if g .server == nil {
140- if err := g .createServer (); err != nil {
141- c .Logger .Fatalf ("failed to create gRPC server: %v" , err )
146+ if err := g .createServer (); err != nil {
147+ c .Logger .Fatalf ("failed to create gRPC server: %v" , err )
142148 c .Metrics ().IncrementCounter (context .Background (), "grpc_server_errors_total" )
143- return
144- }
145- }
149+
150+ return
151+ }
152+ }
146153
147154 addr := ":" + strconv .Itoa (g .port )
148155
149156 c .Logger .Infof ("starting gRPC server at %s" , addr )
150157
151- listener , err := net .Listen ("tcp" , addr )
158+ listener , err := ( & net.ListenConfig {}). Listen (context . Background (), "tcp" , addr )
152159 if err != nil {
153160 c .Logger .Errorf ("error in starting gRPC server at %s: %s" , addr , err )
154161 c .Metrics ().IncrementCounter (context .Background (), "grpc_server_errors_total" )
155162 c .Metrics ().SetGauge ("grpc_server_status" , 0 )
163+
156164 return
157165 }
158-
166+
159167 c .Metrics ().SetGauge ("grpc_server_status" , 1 )
160168
161169 if err := g .server .Serve (listener ); err != nil {
162170 c .Logger .Errorf ("error in starting gRPC server at %s: %s" , addr , err )
163171 c .Metrics ().IncrementCounter (context .Background (), "grpc_server_errors_total" )
164172 c .Metrics ().SetGauge ("grpc_server_status" , 0 )
173+
165174 return
166175 }
167-
176+
168177 c .Logger .Infof ("gRPC server stopped on %s" , addr )
169178 c .Metrics ().SetGauge ("grpc_server_status" , 0 )
170179}
@@ -183,27 +192,22 @@ func (g *grpcServer) Shutdown(ctx context.Context) error {
183192 })
184193}
185194
186- var (
187- errNonAddressable = errors .New ("cannot inject container as it is not addressable or is nil" )
188- )
189-
190195// RegisterService adds a gRPC service to the GoFr application.
191196func (a * App ) RegisterService (desc * grpc.ServiceDesc , impl any ) {
192-
193197 if ! a .grpcRegistered && ! isPortAvailable (a .grpcServer .port ) {
194198 a .container .Logger .Fatalf ("gRPC port %d is blocked or unreachable" , a .grpcServer .port )
195199 }
196200
197- if ! a .grpcRegistered {
198- if err := a .grpcServer .createServer (); err != nil {
199- a .container .Logger .Errorf ("failed to create gRPC server for service %s: %v" , desc .ServiceName , err )
200- return
201- }
202- }
201+ if ! a .grpcRegistered {
202+ if err := a .grpcServer .createServer (); err != nil {
203+ a .container .Logger .Errorf ("failed to create gRPC server for service %s: %v" , desc .ServiceName , err )
204+ return
205+ }
206+ }
203207
204208 a .container .Logger .Infof ("registering gRPC Server: %s" , desc .ServiceName )
205209 a .grpcServer .server .RegisterService (desc , impl )
206-
210+
207211 a .container .Metrics ().IncrementCounter (context .Background (), "grpc_services_registered_total" )
208212
209213 err := injectContainer (impl , a .container )
@@ -238,8 +242,8 @@ func injectContainer(impl any, c *container.Container) error {
238242
239243 if f .Type == reflect .TypeOf (c ) {
240244 if ! v .CanSet () {
241- c .Logger .Error (errNonAddressable )
242- return errNonAddressable
245+ c .Logger .Error (ErrNonAddressable )
246+ return ErrNonAddressable
243247 }
244248
245249 v .Set (reflect .ValueOf (c ))
@@ -250,8 +254,8 @@ func injectContainer(impl any, c *container.Container) error {
250254
251255 if f .Type == reflect .TypeOf (* c ) {
252256 if ! v .CanSet () {
253- c .Logger .Error (errNonAddressable )
254- return errNonAddressable
257+ c .Logger .Error (ErrNonAddressable )
258+ return ErrNonAddressable
255259 }
256260
257261 v .Set (reflect .ValueOf (* c ))
0 commit comments