feat: add environment variables for leader election timing configuration

Add support for configuring leader election timing parameters through
environment variables.

Changes:
- Add environment variable parsing in operator/main.go for:
  - KEDA_HTTP_OPERATOR_LEADER_ELECTION_LEASE_DURATION
  - KEDA_HTTP_OPERATOR_LEADER_ELECTION_RENEW_DEADLINE
  - KEDA_HTTP_OPERATOR_LEADER_ELECTION_RETRY_PERIOD
- Pass parsed durations to ctrl.NewManager Options
- Add test in operator/main_test.go covering parsing, defaults and error handling
- Add configuration docs

All three environment variables are optional. When not set, controller-runtime
uses Kubernetes defaults (LeaseDuration: 15s, RenewDeadline: 10s, RetryPeriod: 2s).
This allows operators to adjust leader election timing for different cluster
configurations and network conditions without requiring code changes.

Fixes: #1331

Signed-off-by: Nader Ziada <[email protected]>

Author: nader-ziada

docs/operate.md

@@ -71,3 +71,24 @@ Optional variables
 `OTEL_EXPORTER_OTLP_TRACES_TIMEOUT` - The batcher timeout in seconds to send batch of data points (`5` by default)
 
 ### Configuring Service Failover
+
+# Configuring the KEDA HTTP Add-on Operator
+
+## Leader Election Timing
+
+When running multiple replicas of the operator for high availability, you can configure the leader election timing parameters:
+
+- **`KEDA_HTTP_OPERATOR_LEADER_ELECTION_LEASE_DURATION`** - Duration that non-leader candidates will wait to force acquire leadership. Default: `15s` (Kubernetes default)
+- **`KEDA_HTTP_OPERATOR_LEADER_ELECTION_RENEW_DEADLINE`** - Duration that the acting leader will retry refreshing leadership before giving up. Default: `10s` (Kubernetes default)
+- **`KEDA_HTTP_OPERATOR_LEADER_ELECTION_RETRY_PERIOD`** - Duration the LeaderElector clients should wait between tries of actions. Default: `2s` (Kubernetes default)
+
+Example usage in deployment:
+```yaml
+env:
+- name: KEDA_HTTP_OPERATOR_LEADER_ELECTION_LEASE_DURATION
+  value: "30s"
+- name: KEDA_HTTP_OPERATOR_LEADER_ELECTION_RENEW_DEADLINE
+  value: "20s"
+- name: KEDA_HTTP_OPERATOR_LEADER_ELECTION_RETRY_PERIOD
+  value: "5s"
+```

operator/main.go

@@ -34,6 +34,7 @@ import (
 	httpv1alpha1 "github.com/kedacore/http-add-on/operator/apis/http/v1alpha1"
 	httpcontrollers "github.com/kedacore/http-add-on/operator/controllers/http"
 	"github.com/kedacore/http-add-on/operator/controllers/http/config"
+	"github.com/kedacore/http-add-on/pkg/util"
 	// +kubebuilder:scaffold:imports
 )
 
@@ -86,6 +87,24 @@ func main() {
 		os.Exit(1)
 	}
 
+	leaseDuration, err := util.ResolveOsEnvDuration("KEDA_HTTP_OPERATOR_LEADER_ELECTION_LEASE_DURATION")
+	if err != nil {
+		setupLog.Error(err, "invalid KEDA_HTTP_OPERATOR_LEADER_ELECTION_LEASE_DURATION")
+		os.Exit(1)
+	}
+
+	renewDeadline, err := util.ResolveOsEnvDuration("KEDA_HTTP_OPERATOR_LEADER_ELECTION_RENEW_DEADLINE")
+	if err != nil {
+		setupLog.Error(err, "invalid KEDA_HTTP_OPERATOR_LEADER_ELECTION_RENEW_DEADLINE")
+		os.Exit(1)
+	}
+
+	retryPeriod, err := util.ResolveOsEnvDuration("KEDA_HTTP_OPERATOR_LEADER_ELECTION_RETRY_PERIOD")
+	if err != nil {
+		setupLog.Error(err, "invalid KEDA_HTTP_OPERATOR_LEADER_ELECTION_RETRY_PERIOD")
+		os.Exit(1)
+	}
+
 	var namespaces map[string]cache.Config
 	if baseConfig.WatchNamespace != "" {
 		namespaces = map[string]cache.Config{
@@ -103,6 +122,9 @@ func main() {
 		LeaderElection:                enableLeaderElection,
 		LeaderElectionID:              "http-add-on.keda.sh",
 		LeaderElectionReleaseOnCancel: true,
+		LeaseDuration:                 leaseDuration,
+		RenewDeadline:                 renewDeadline,
+		RetryPeriod:                   retryPeriod,
 		Cache: cache.Options{
 			DefaultNamespaces: namespaces,
 		},

operator/main_test.go

@@ -0,0 +1,128 @@
+/*
+Copyright 2025 The KEDA Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package main
+
+import (
+	"testing"
+	"time"
+
+	"github.com/kedacore/http-add-on/pkg/util"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLeaderElectionEnvVarsIntegration(t *testing.T) {
+	tests := []struct {
+		name          string
+		envVars       map[string]string
+		expectedLease *time.Duration
+		expectedRenew *time.Duration
+		expectedRetry *time.Duration
+		expectError   bool
+	}{
+		{
+			name: "all environment variables set with valid values",
+			envVars: map[string]string{
+				"KEDA_HTTP_OPERATOR_LEADER_ELECTION_LEASE_DURATION": "30s",
+				"KEDA_HTTP_OPERATOR_LEADER_ELECTION_RENEW_DEADLINE": "20s",
+				"KEDA_HTTP_OPERATOR_LEADER_ELECTION_RETRY_PERIOD":   "5s",
+			},
+			expectedLease: durationPtr(30 * time.Second),
+			expectedRenew: durationPtr(20 * time.Second),
+			expectedRetry: durationPtr(5 * time.Second),
+			expectError:   false,
+		},
+		{
+			name:          "no environment variables set - should return nil for defaults",
+			envVars:       map[string]string{},
+			expectedLease: nil,
+			expectedRenew: nil,
+			expectedRetry: nil,
+			expectError:   false,
+		},
+		{
+			name: "invalid lease duration",
+			envVars: map[string]string{
+				"KEDA_HTTP_OPERATOR_LEADER_ELECTION_LEASE_DURATION": "invalid",
+			},
+			expectError: true,
+		},
+		{
+			name: "invalid renew deadline",
+			envVars: map[string]string{
+				"KEDA_HTTP_OPERATOR_LEADER_ELECTION_RENEW_DEADLINE": "not-a-duration",
+			},
+			expectError: true,
+		},
+		{
+			name: "invalid retry period",
+			envVars: map[string]string{
+				"KEDA_HTTP_OPERATOR_LEADER_ELECTION_RETRY_PERIOD": "xyz",
+			},
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+
+			for key, value := range tt.envVars {
+				t.Setenv(key, value)
+			}
+
+			leaseDuration, leaseErr := util.ResolveOsEnvDuration("KEDA_HTTP_OPERATOR_LEADER_ELECTION_LEASE_DURATION")
+			renewDeadline, renewErr := util.ResolveOsEnvDuration("KEDA_HTTP_OPERATOR_LEADER_ELECTION_RENEW_DEADLINE")
+			retryPeriod, retryErr := util.ResolveOsEnvDuration("KEDA_HTTP_OPERATOR_LEADER_ELECTION_RETRY_PERIOD")
+
+			if tt.expectError {
+				// At least one of the errors should be non-nil
+				hasError := false
+				if _, ok := tt.envVars["KEDA_HTTP_OPERATOR_LEADER_ELECTION_LEASE_DURATION"]; ok && leaseErr != nil {
+					hasError = true
+				}
+				if _, ok := tt.envVars["KEDA_HTTP_OPERATOR_LEADER_ELECTION_RENEW_DEADLINE"]; ok && renewErr != nil {
+					hasError = true
+				}
+				if _, ok := tt.envVars["KEDA_HTTP_OPERATOR_LEADER_ELECTION_RETRY_PERIOD"]; ok && retryErr != nil {
+					hasError = true
+				}
+				if !hasError {
+					t.Errorf("expected error but got none")
+				}
+			} else {
+				// No errors expected
+				if leaseErr != nil {
+					t.Errorf("unexpected error for lease duration: %v", leaseErr)
+				}
+				if renewErr != nil {
+					t.Errorf("unexpected error for renew deadline: %v", renewErr)
+				}
+				if retryErr != nil {
+					t.Errorf("unexpected error for retry period: %v", retryErr)
+				}
+
+				// Verify the parsed values match expectations
+				assert.Equal(t, tt.expectedLease, leaseDuration)
+				assert.Equal(t, tt.expectedRenew, renewDeadline)
+				assert.Equal(t, tt.expectedRetry, retryPeriod)
+			}
+		})
+	}
+}
+
+func durationPtr(d time.Duration) *time.Duration {
+	return &d
+}