fix: wire keepalive configuration fields into gRPC server options

controller/cmd/main.go

@@ -281,8 +281,8 @@ func main() {
 			ResourceKey:  "jumpstarter-kind",
 			NameKey:      "jumpstarter-name",
 		}),
-		Router:       router,
-		ServerOption: option,
+		Router:        router,
+		ServerOptions: option,
 	}).SetupWithManager(mgr); err != nil {
 		setupLog.Error(err, "unable to create service", "service", "Controller")
 		os.Exit(1)

controller/cmd/router/main.go

@@ -75,7 +75,7 @@ func main() {
 	}
 
 	svc := service.RouterService{
-		ServerOption: serverOption,
+		ServerOptions: serverOption,
 	}
 
 	err = svc.Start(ctx)

controller/internal/config/config.go

@@ -19,7 +19,7 @@ func LoadRouterConfiguration(
 	ctx context.Context,
 	client client.Reader,
 	key client.ObjectKey,
-) (grpc.ServerOption, error) {
+) ([]grpc.ServerOption, error) {
 	var configmap corev1.ConfigMap
 	if err := client.Get(ctx, key, &configmap); err != nil {
 		return nil, err
@@ -51,7 +51,7 @@ func LoadConfiguration(
 	key client.ObjectKey,
 	signer *oidc.Signer,
 	certificateAuthority string,
-) (authenticator.Token, string, Router, grpc.ServerOption, *Provisioning, error) {
+) (authenticator.Token, string, Router, []grpc.ServerOption, *Provisioning, error) {
 	var configmap corev1.ConfigMap
 	if err := client.Get(ctx, key, &configmap); err != nil {
 		return nil, "", nil, nil, nil, err
@@ -82,10 +82,12 @@ func LoadConfiguration(
 			return nil, "", nil, nil, nil, err
 		}
 
-		return authenticator, prefix, router, grpc.KeepaliveEnforcementPolicy(keepalive.EnforcementPolicy{
-			MinTime:             1 * time.Second,
-			PermitWithoutStream: true,
-		}), &Provisioning{Enabled: false}, nil
+		return authenticator, prefix, router, []grpc.ServerOption{
+			grpc.KeepaliveEnforcementPolicy(keepalive.EnforcementPolicy{
+				MinTime:             1 * time.Second,
+				PermitWithoutStream: true,
+			}),
+		}, &Provisioning{Enabled: false}, nil
 	}
 
 	rawConfig, ok := configmap.Data["config"]

controller/internal/config/grpc.go

@@ -7,25 +7,62 @@ import (
 	"google.golang.org/grpc/keepalive"
 )
 
-// LoadGrpcConfiguration loads the gRPC server configuration from the parsed Config struct.
-// It creates a gRPC server option with keepalive enforcement policy configured.
-func LoadGrpcConfiguration(config Grpc) (grpc.ServerOption, error) {
+func LoadGrpcConfiguration(config Grpc) ([]grpc.ServerOption, error) {
 	ka := config.Keepalive
 
-	// Parse MinTime with default of 1s
 	minTime, err := ParseDuration(ka.MinTime)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse keepalive minTime: %w", err)
 	}
 	if minTime == 0 {
-		minTime = 1e9 // 1 second default
+		minTime = 1e9
 	}
 
-	// Create the keepalive enforcement policy
 	policy := keepalive.EnforcementPolicy{
 		MinTime:             minTime,
 		PermitWithoutStream: ka.PermitWithoutStream,
 	}
 
-	return grpc.KeepaliveEnforcementPolicy(policy), nil
+	options := []grpc.ServerOption{
+		grpc.KeepaliveEnforcementPolicy(policy),
+	}
+
+	timeout, err := ParseDuration(ka.Timeout)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse keepalive timeout: %w", err)
+	}
+
+	intervalTime, err := ParseDuration(ka.IntervalTime)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse keepalive intervalTime: %w", err)
+	}
+
+	maxConnectionIdle, err := ParseDuration(ka.MaxConnectionIdle)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse keepalive maxConnectionIdle: %w", err)
+	}
+
+	maxConnectionAge, err := ParseDuration(ka.MaxConnectionAge)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse keepalive maxConnectionAge: %w", err)
+	}
+
+	maxConnectionAgeGrace, err := ParseDuration(ka.MaxConnectionAgeGrace)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse keepalive maxConnectionAgeGrace: %w", err)
+	}
+
+	params := keepalive.ServerParameters{
+		Timeout:               timeout,
+		Time:                  intervalTime,
+		MaxConnectionIdle:     maxConnectionIdle,
+		MaxConnectionAge:      maxConnectionAge,
+		MaxConnectionAgeGrace: maxConnectionAgeGrace,
+	}
+
+	if params != (keepalive.ServerParameters{}) {
+		options = append(options, grpc.KeepaliveParams(params))
+	}
+
+	return options, nil
 }

controller/internal/config/grpc_test.go

@@ -0,0 +1,190 @@
+package config
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestLoadGrpcConfigurationMinimalConfigReturnsSlice(t *testing.T) {
+	cfg := Grpc{
+		Keepalive: Keepalive{
+			MinTime:             "5s",
+			PermitWithoutStream: true,
+		},
+	}
+
+	options, err := LoadGrpcConfiguration(cfg)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(options) < 1 {
+		t.Fatalf("expected at least 1 server option, got %d", len(options))
+	}
+}
+
+func TestLoadGrpcConfigurationWithTimeoutAndIntervalTime(t *testing.T) {
+	cfg := Grpc{
+		Keepalive: Keepalive{
+			MinTime:             "1s",
+			PermitWithoutStream: true,
+			Timeout:             "30s",
+			IntervalTime:        "5s",
+		},
+	}
+
+	options, err := LoadGrpcConfiguration(cfg)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(options) != 2 {
+		t.Fatalf("expected 2 server options (enforcement policy + server parameters), got %d", len(options))
+	}
+}
+
+func TestLoadGrpcConfigurationInvalidTimeoutReturnsError(t *testing.T) {
+	cfg := Grpc{
+		Keepalive: Keepalive{
+			MinTime: "1s",
+			Timeout: "abc",
+		},
+	}
+
+	_, err := LoadGrpcConfiguration(cfg)
+	if err == nil {
+		t.Fatal("expected error for invalid timeout, got nil")
+	}
+
+	if !strings.Contains(err.Error(), "timeout") {
+		t.Fatalf("expected error mentioning 'timeout', got: %v", err)
+	}
+}
+
+func TestLoadGrpcConfigurationInvalidIntervalTimeReturnsError(t *testing.T) {
+	cfg := Grpc{
+		Keepalive: Keepalive{
+			MinTime:      "1s",
+			IntervalTime: "xyz",
+		},
+	}
+
+	_, err := LoadGrpcConfiguration(cfg)
+	if err == nil {
+		t.Fatal("expected error for invalid intervalTime, got nil")
+	}
+
+	if !strings.Contains(err.Error(), "intervalTime") {
+		t.Fatalf("expected error mentioning 'intervalTime', got: %v", err)
+	}
+}
+
+func TestLoadGrpcConfigurationWithConnectionLifetimeFields(t *testing.T) {
+	cfg := Grpc{
+		Keepalive: Keepalive{
+			MinTime:               "1s",
+			PermitWithoutStream:   true,
+			MaxConnectionIdle:     "5m",
+			MaxConnectionAge:      "30m",
+			MaxConnectionAgeGrace: "10s",
+		},
+	}
+
+	options, err := LoadGrpcConfiguration(cfg)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(options) != 2 {
+		t.Fatalf("expected 2 server options (enforcement policy + server parameters), got %d", len(options))
+	}
+}
+
+func TestLoadGrpcConfigurationInvalidConnectionLifetimeFields(t *testing.T) {
+	tests := []struct {
+		name      string
+		cfg       Grpc
+		wantInErr string
+	}{
+		{
+			name: "invalid maxConnectionIdle",
+			cfg: Grpc{
+				Keepalive: Keepalive{
+					MinTime:           "1s",
+					MaxConnectionIdle: "bad",
+				},
+			},
+			wantInErr: "maxConnectionIdle",
+		},
+		{
+			name: "invalid maxConnectionAge",
+			cfg: Grpc{
+				Keepalive: Keepalive{
+					MinTime:          "1s",
+					MaxConnectionAge: "bad",
+				},
+			},
+			wantInErr: "maxConnectionAge",
+		},
+		{
+			name: "invalid maxConnectionAgeGrace",
+			cfg: Grpc{
+				Keepalive: Keepalive{
+					MinTime:               "1s",
+					MaxConnectionAgeGrace: "bad",
+				},
+			},
+			wantInErr: "maxConnectionAgeGrace",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := LoadGrpcConfiguration(tt.cfg)
+			if err == nil {
+				t.Fatalf("expected error for %s, got nil", tt.wantInErr)
+			}
+			if !strings.Contains(err.Error(), tt.wantInErr) {
+				t.Fatalf("expected error mentioning %q, got: %v", tt.wantInErr, err)
+			}
+		})
+	}
+}
+
+func TestLoadGrpcConfigurationEmptyKeepaliveFieldsReturnZeroValueParams(t *testing.T) {
+	cfg := Grpc{
+		Keepalive: Keepalive{
+			MinTime:               "1s",
+			PermitWithoutStream:   true,
+			Timeout:               "",
+			IntervalTime:          "",
+			MaxConnectionIdle:     "",
+			MaxConnectionAge:      "",
+			MaxConnectionAgeGrace: "",
+		},
+	}
+
+	options, err := LoadGrpcConfiguration(cfg)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(options) != 1 {
+		t.Fatalf("expected 1 server option (enforcement policy only, no server parameters for zero values), got %d", len(options))
+	}
+}
+
+func TestLoadGrpcConfigurationEmptyKeepaliveStructUsesDefaults(t *testing.T) {
+	cfg := Grpc{
+		Keepalive: Keepalive{},
+	}
+
+	options, err := LoadGrpcConfiguration(cfg)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(options) != 1 {
+		t.Fatalf("expected 1 server option (enforcement policy with default 1s MinTime), got %d", len(options))
+	}
+}

controller/internal/service/controller_service.go

@@ -72,14 +72,14 @@ import (
 // ControllerService exposes a gRPC service
 type ControllerService struct {
 	pb.UnimplementedControllerServiceServer
-	Client       client.WithWatch
-	Scheme       *runtime.Scheme
-	Authn        authentication.ContextAuthenticator
-	Authz        authorizer.Authorizer
-	Attr         authorization.ContextAttributesGetter
-	ServerOption grpc.ServerOption
-	Router       config.Router
-	listenQueues sync.Map
+	Client        client.WithWatch
+	Scheme        *runtime.Scheme
+	Authn         authentication.ContextAuthenticator
+	Authz         authorizer.Authorizer
+	Attr          authorization.ContextAttributesGetter
+	ServerOptions []grpc.ServerOption
+	Router        config.Router
+	listenQueues  sync.Map
 }
 
 type wrappedStream struct {
@@ -938,8 +938,7 @@ func (s *ControllerService) Start(ctx context.Context) error {
 		}
 	}
 
-	server := grpc.NewServer(
-		s.ServerOption,
+	opts := append(s.ServerOptions,
 		grpc.ChainUnaryInterceptor(func(
 			gctx context.Context,
 			req any,
@@ -957,6 +956,7 @@ func (s *ControllerService) Start(ctx context.Context) error {
 			return handler(srv, &wrappedStream{ServerStream: ss})
 		}, recovery.StreamServerInterceptor()),
 	)
+	server := grpc.NewServer(opts...)
 
 	pb.RegisterControllerServiceServer(server, s)
 	cpb.RegisterClientServiceServer(

controller/internal/service/router_service.go

@@ -40,8 +40,8 @@ import (
 // RouterService exposes a gRPC service
 type RouterService struct {
 	pb.UnimplementedRouterServiceServer
-	ServerOption grpc.ServerOption
-	pending      sync.Map
+	ServerOptions []grpc.ServerOption
+	pending       sync.Map
 }
 
 type streamContext struct {
@@ -150,12 +150,13 @@ func (s *RouterService) Start(ctx context.Context) error {
 		}
 	}
 
-	server := grpc.NewServer(
+	opts := []grpc.ServerOption{
 		grpc.Creds(credentials.NewServerTLSFromCert(cert)),
 		grpc.ChainUnaryInterceptor(recovery.UnaryServerInterceptor()),
 		grpc.ChainStreamInterceptor(recovery.StreamServerInterceptor()),
-		s.ServerOption,
-	)
+	}
+	opts = append(opts, s.ServerOptions...)
+	server := grpc.NewServer(opts...)
 
 	pb.RegisterRouterServiceServer(server, s)