Make exporter lastseen timeout configurable

Author: mangelajo

.github/workflows/e2e.yaml

@@ -19,10 +19,12 @@ jobs:
           controller-ref: ${{ github.ref }}
           # use the matching branch on the jumpstarter repo
           jumpstarter-ref: ${{ github.event.pull_request.base.ref }}
-  e2e-tests-28d6b1cc3b49ab9ae176918ab9709a2e2522c97e:
+  # test the current controller with the previous version of python and E2E tests
+  # to ensure backwards compatibility
+  e2e-tests-release-0-7:
     runs-on: ubuntu-latest
     steps:
-      - uses: jumpstarter-dev/jumpstarter-e2e@11a5ce6734be9f089ec3ea6ebf55284616f67fe8
+      - uses: jumpstarter-dev/jumpstarter-e2e@release-0.7
         with:
           controller-ref: ${{ github.ref }}
-          jumpstarter-ref: 28d6b1cc3b49ab9ae176918ab9709a2e2522c97e
+          jumpstarter-ref: release-0.7

cmd/main.go

@@ -154,7 +154,7 @@ func main() {
 		os.Exit(1)
 	}
 
-	authenticator, prefix, router, option, provisioning, err := config.LoadConfiguration(
+	authenticator, prefix, router, option, provisioning, exporterOptions, err := config.LoadConfiguration(
 		context.Background(),
 		mgr.GetAPIReader(),
 		mgr.GetScheme(),
@@ -174,9 +174,10 @@ func main() {
 	}
 
 	if err = (&controller.ExporterReconciler{
-		Client: mgr.GetClient(),
-		Scheme: mgr.GetScheme(),
-		Signer: oidcSigner,
+		Client:          mgr.GetClient(),
+		Scheme:          mgr.GetScheme(),
+		Signer:          oidcSigner,
+		ExporterOptions: *exporterOptions,
 	}).SetupWithManager(mgr); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "Exporter")
 		os.Exit(1)

deploy/helm/jumpstarter/charts/jumpstarter-controller/model.py

@@ -203,6 +203,15 @@ class JWTAuthenticator(BaseModel):
     userValidationRules: Optional[List[UserValidationRule]] = None
 
 
+class ExporterOptions(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    offlineTimeout: Optional[str] = Field(
+        None,
+        description="How long to wait before marking the exporter as offline",
+    )
+
+
 class Authentication(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
@@ -219,6 +228,7 @@ class JumpstarterConfig(BaseModel):
     provisioning: Optional[Provisioning] = None
     authentication: Optional[Authentication] = None
     grpc: Optional[Grpc] = None
+    exporterOptions: Optional[ExporterOptions] = None
 
 
 class Nodeport(BaseModel):

deploy/helm/jumpstarter/charts/jumpstarter-controller/values.schema.json

@@ -214,6 +214,26 @@
       "title": "ClaimValidationRule",
       "type": "object"
     },
+    "ExporterOptions": {
+      "additionalProperties": false,
+      "properties": {
+        "offlineTimeout": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "How long to wait before marking the exporter as offline",
+          "title": "Offlinetimeout"
+        }
+      },
+      "title": "ExporterOptions",
+      "type": "object"
+    },
     "ExtraItem": {
       "additionalProperties": false,
       "properties": {
@@ -638,6 +658,17 @@
             }
           ],
           "default": null
+        },
+        "exporterOptions": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/ExporterOptions"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null
         }
       },
       "title": "JumpstarterConfig",
@@ -671,6 +702,71 @@
           "default": null,
           "description": "Whether to allow keepalive pings even when there are no active streams(RPCs)",
           "title": "Permitwithoutstream"
+        },
+        "timeout": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "How long the server waits for a ping response before closing the connection",
+          "title": "Timeout"
+        },
+        "maxConnectionIdle": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "Maximum time a connection can be idle before being closed",
+          "title": "Maxconnectionidle"
+        },
+        "maxConnectionAge": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "Maximum lifetime of a connection before it's closed",
+          "title": "Maxconnectionage"
+        },
+        "maxConnectionAgeGrace": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "Grace period after max connection age before forcible closure",
+          "title": "Maxconnectionagegrace"
+        },
+        "time": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "How often the server sends keepalive pings to clients",
+          "title": "Time"
         }
       },
       "title": "Keepalive",

deploy/helm/jumpstarter/values.yaml

@@ -42,6 +42,8 @@ global:
 ## @param jumpstarter-controller.config.authentication.internal.prefix. Prefix to add to the subject claim of the tokens issued by the builtin authenticator.
 ## @param jumpstarter-controller.config.authentication.jwt. External OIDC authentication, see https://kubernetes.io/docs/reference/access-authn-authz/authentication/#using-authentication-configuration for documentation
 
+## @param jumpstarter-controller.config.exporterOptions.offlineTimeout. How long to wait before marking the exporter as offline.
+
 ## @section Ingress And Route parameters
 ## @descriptionStart This section contains parameters for the Ingress and Route configurations.
 ## You can enable either the gRPC ingress or the OpenShift route but not both.
@@ -77,6 +79,9 @@ jumpstarter-controller:
     namespace: ""
 
     config:
+      exporterOptions:
+        offlineTimeout: 180s # how long to wait before marking the exporter as offline
+
       grpc:
         keepalive:
           # EnforcementPolicy parameters

internal/config/config.go

@@ -49,30 +49,30 @@ 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, *ExporterOptions, error) {
 	var configmap corev1.ConfigMap
 	if err := client.Get(ctx, key, &configmap); err != nil {
-		return nil, "", nil, nil, nil, err
+		return nil, "", nil, nil, nil, nil, err
 	}
 
 	rawRouter, ok := configmap.Data["router"]
 	if !ok {
-		return nil, "", nil, nil, nil, fmt.Errorf("LoadConfiguration: missing router section")
+		return nil, "", nil, nil, nil, nil, fmt.Errorf("LoadConfiguration: missing router section")
 	}
 
 	var router Router
 	if err := yaml.Unmarshal([]byte(rawRouter), &router); err != nil {
-		return nil, "", nil, nil, nil, err
+		return nil, "", nil, nil, nil, nil, err
 	}
 
 	rawConfig, ok := configmap.Data["config"]
 	if !ok {
-		return nil, "", nil, nil, nil, fmt.Errorf("LoadConfiguration: missing config section")
+		return nil, "", nil, nil, nil, nil, fmt.Errorf("LoadConfiguration: missing config section")
 	}
 
 	var config Config
 	if err := yaml.UnmarshalStrict([]byte(rawConfig), &config); err != nil {
-		return nil, "", nil, nil, nil, err
+		return nil, "", nil, nil, nil, nil, err
 	}
 
 	authenticator, prefix, err := LoadAuthenticationConfiguration(
@@ -83,13 +83,16 @@ func LoadConfiguration(
 		certificateAuthority,
 	)
 	if err != nil {
-		return nil, "", nil, nil, nil, err
+		return nil, "", nil, nil, nil, nil, err
 	}
 
 	serverOptions, err := LoadGrpcConfiguration(config.Grpc)
 	if err != nil {
-		return nil, "", nil, nil, nil, err
+		return nil, "", nil, nil, nil, nil, err
 	}
 
-	return authenticator, prefix, router, serverOptions, &config.Provisioning, nil
+	// Preprocess configuration values (parse durations, cache expensive operations, etc.)
+	config.ExporterOptions.PreprocessConfig()
+
+	return authenticator, prefix, router, serverOptions, &config.Provisioning, &config.ExporterOptions, nil
 }

internal/config/types.go

@@ -1,13 +1,16 @@
 package config
 
 import (
+	"time"
+
 	apiserverv1beta1 "k8s.io/apiserver/pkg/apis/apiserver/v1beta1"
 )
 
 type Config struct {
-	Authentication Authentication `json:"authentication"`
-	Provisioning   Provisioning   `json:"provisioning"`
-	Grpc           Grpc           `json:"grpc"`
+	Authentication  Authentication  `json:"authentication"`
+	Provisioning    Provisioning    `json:"provisioning"`
+	Grpc            Grpc            `json:"grpc"`
+	ExporterOptions ExporterOptions `json:"exporterOptions"`
 }
 
 type Authentication struct {
@@ -40,6 +43,36 @@ type Keepalive struct {
 	Time                  string `json:"time,omitempty"`                  // How often server sends pings
 }
 
+type ExporterOptions struct {
+	OfflineTimeout    string        `json:"offlineTimeout,omitempty"` // How long to wait before marking the exporter as offline
+	offlineTimeoutDur time.Duration // Pre-calculated duration, set during LoadConfiguration
+}
+
+// PreprocessConfig parses and caches configuration values that require processing
+// This method should be called once during configuration loading to pre-calculate
+// expensive operations and cache the results for efficient retrieval
+func (e *ExporterOptions) PreprocessConfig() {
+	// Parse and cache the offline timeout duration
+	if e.OfflineTimeout == "" {
+		e.offlineTimeoutDur = time.Minute // Default fallback
+	} else {
+		duration, err := time.ParseDuration(e.OfflineTimeout)
+		if err != nil {
+			// If parsing fails, use default fallback
+			e.offlineTimeoutDur = time.Minute
+		} else {
+			e.offlineTimeoutDur = duration
+		}
+	}
+
+	// Future configuration parsing can be added here
+}
+
+// GetOfflineTimeout returns the pre-calculated offline timeout duration
+func (e *ExporterOptions) GetOfflineTimeout() time.Duration {
+	return e.offlineTimeoutDur
+}
+
 type Router map[string]RouterEntry
 
 type RouterEntry struct {

internal/controller/exporter_controller.go

@@ -30,14 +30,16 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/log"
 
 	jumpstarterdevv1alpha1 "github.com/jumpstarter-dev/jumpstarter-controller/api/v1alpha1"
+	"github.com/jumpstarter-dev/jumpstarter-controller/internal/config"
 	"github.com/jumpstarter-dev/jumpstarter-controller/internal/oidc"
 )
 
 // ExporterReconciler reconciles a Exporter object
 type ExporterReconciler struct {
 	client.Client
-	Scheme *runtime.Scheme
-	Signer *oidc.Signer
+	Scheme          *runtime.Scheme
+	Signer          *oidc.Signer
+	ExporterOptions config.ExporterOptions
 }
 
 // +kubebuilder:rbac:groups=jumpstarter.dev,resources=exporters,verbs=get;list;watch;create;update;patch;delete
@@ -158,6 +160,7 @@ func (r *ExporterReconciler) reconcileStatusConditionsOnline(
 	exporter *jumpstarterdevv1alpha1.Exporter,
 ) (ctrl.Result, error) {
 	var requeueAfter time.Duration = 0
+	offlineTimeout := r.ExporterOptions.GetOfflineTimeout()
 
 	if exporter.Status.LastSeen.IsZero() {
 		meta.SetStatusCondition(&exporter.Status.Conditions, metav1.Condition{
@@ -168,13 +171,13 @@ func (r *ExporterReconciler) reconcileStatusConditionsOnline(
 			Message:            "Never seen",
 		})
 		// marking the exporter offline, no need to requeue
-	} else if time.Since(exporter.Status.LastSeen.Time) > time.Minute {
+	} else if time.Since(exporter.Status.LastSeen.Time) > offlineTimeout {
 		meta.SetStatusCondition(&exporter.Status.Conditions, metav1.Condition{
 			Type:               string(jumpstarterdevv1alpha1.ExporterConditionTypeOnline),
 			Status:             metav1.ConditionFalse,
 			ObservedGeneration: exporter.Generation,
 			Reason:             "Seen",
-			Message:            "Last seen more than 1 minute ago",
+			Message:            fmt.Sprintf("Last seen more than %v ago", offlineTimeout),
 		})
 		// marking the exporter offline, no need to requeue
 	} else {
@@ -183,10 +186,27 @@ func (r *ExporterReconciler) reconcileStatusConditionsOnline(
 			Status:             metav1.ConditionTrue,
 			ObservedGeneration: exporter.Generation,
 			Reason:             "Seen",
-			Message:            "Last seen less than 1 minute ago",
+			Message:            fmt.Sprintf("Last seen less than %v ago", offlineTimeout),
 		})
-		// marking the exporter online, requeue after 30 seconds
-		requeueAfter = time.Second * 30
+
+		// Calculate when the exporter will go offline
+		expirationTime := exporter.Status.LastSeen.Add(offlineTimeout)
+		timeUntilExpiration := time.Until(expirationTime)
+
+		// Set requeue time to be just after expiration (with a small safety margin)
+		// This way we can definitively determine if the exporter expired or was updated
+		safetyMargin := 10 * time.Second
+		if timeUntilExpiration > 0 {
+			// Exporter hasn't expired yet, requeue after expiration + safety margin
+			requeueAfter = timeUntilExpiration + safetyMargin
+			// Cap the requeue time to avoid very long waits
+			if requeueAfter > 5*time.Minute {
+				requeueAfter = 5 * time.Minute
+			}
+		} else {
+			// Exporter should have already expired, requeue in safety margin time
+			requeueAfter = safetyMargin
+		}
 	}
 
 	if exporter.Status.Devices == nil {