feat: Add API Changes and Validation for FleetAutoscaler Schedule/Chain Policy

examples/chainfleetautoscaler.yaml

@@ -27,24 +27,24 @@ kind: FleetAutoscaler
 metadata:
   name: chain-fleet-autoscaler
 spec:
+  fleetName: "fleet-example"
   policy:
     # Chain based policy for autoscaling.
     type: Chain
     chain:
       # Id of chain entry. If not set, the Id will be defaulted to the index of the entry within the chain.
       - id: "weekday"
-        type: Schedule  # Schedule based condition.
         schedule:
           between:
-            # The policy becomes eligible for application starting on Feb 20, 2024 at 4:04 PM EST. If not set, the policy will immediately be eligible for application.
-            start: "2024-02-20T16:04:04-05:00"
-            # The policy becomes ineligible for application on Feb 23, 2024 at 4:04 PM EST. If not set, the policy will always be eligible for application (after the start time).
-            end: "2024-02-23T16:04:04-05:00"
+            # The policy becomes eligible for application starting on Feb 20, 2100 at 4:04 PM EST. If not set, the policy will immediately be eligible for application.
+            start: "2100-02-20T16:04:04-05:00"
+            # The policy becomes ineligible for application on Feb 23, 2100 at 4:04 PM EST. If not set, the policy will always be eligible for application (after the start time).
+            end: "2100-02-23T16:04:04-05:00"
           activePeriod:
             # Timezone to be used for the startCron field. Defaults to UTC if not set.
             timezone: "America/New_York"
             # Start applying the policy everyday at 1:00 AM EST. If not set, the policy will always be applied in the .between window.
-            # (Only eligible starting on Feb 20, 2024 at 4:04 PM).
+            # (Only eligible starting on Feb 20, 2100 at 4:04 PM).
             startCron: "0 1 * * 0"
             # Only apply the policy for 5 hours. If not set, the duration will be defaulted to always/indefinite.
             duration: "5h"
@@ -57,18 +57,17 @@ spec:
             maxReplicas: 2000
       # Id of chain entry. If not set, the Id will be defaulted to the index of the entry within the chain list.
       - id: "weekend"
-        type: Schedule
         schedule:
           between:
-            # The policy becomes eligible for application starting on Feb 24, 2024 at 4:05 PM EST. If not set, the policy will immediately be eligible for application.
-            start: "2024-02-24T16:04:05-05:00"
-            # The policy becomes ineligible for application starting on Feb 26, 2024 at 4:05 PM EST. If not set, the policy will always be eligible for application (after the start time).
-            end: "2024-02-26T16:04:05-05:00"
+            # The policy becomes eligible for application starting on Feb 24, 2100 at 4:05 PM EST. If not set, the policy will immediately be eligible for application.
+            start: "2100-02-24T16:04:05-05:00"
+            # The policy becomes ineligible for application starting on Feb 26, 2100 at 4:05 PM EST. If not set, the policy will always be eligible for application (after the start time).
+            end: "2100-02-26T16:04:05-05:00"
           activePeriod:
             # Timezone to be used for the startCron field. Defaults to UTC if not set.
             timezone: "America/New_York"
             # Start applying the policy everyday at 1:00 AM EST. If not set, the policy will always be applied in the .between window.
-            # (Only eligible starting on Feb 24, 2024 at 4:05 PM EST)
+            # (Only eligible starting on Feb 24, 2100 at 4:05 PM EST)
             startCron: "0 1 * * 0"
             # Only apply the policy for 7 hours. If not set the duration will be defaulted to always/indefinite.
             duration: "7h"

go.mod

@@ -23,6 +23,7 @@ require (
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822
 	github.com/pkg/errors v0.9.1
 	github.com/prometheus/client_golang v1.16.0
+	github.com/robfig/cron/v3 v3.0.1
 	github.com/sirupsen/logrus v1.9.0
 	github.com/spf13/pflag v1.0.5
 	github.com/spf13/viper v1.7.0

go.sum

@@ -381,6 +381,8 @@ github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7z
 github.com/prometheus/procfs v0.10.1 h1:kYK1Va/YMlutzCGazswoHKo//tZVlFpKYh+PymziUAg=
 github.com/prometheus/procfs v0.10.1/go.mod h1:nwNm2aOCAYw8uTR/9bWRREkZFxAUcWzPHWJq+XBB/FM=
 github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
+github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
+github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=

install/helm/agones/templates/crds/_fleetautoscalerpolicy.yaml

@@ -118,29 +118,33 @@ policy:
       nullable: true
       items:
         type: object
-        nullable: true
         required:
           - policy
         properties:
           id: # The Id of a chain entry.
             type: string
           schedule: # Defines when the policy is applied.
             type: object
+            nullable: true
             properties:
               between:
                 type: object
-                start: # Defines when to start evaluating the active period, must conform to RFC3339.
-                  type: string
-                end: # Defines when to stop evaluating the active period, must conform to RFC3339.
-                  type: string
+                nullable: true
+                properties:
+                  start: # Defines when to start evaluating the active period, must conform to RFC3339.
+                    type: string
+                  end: # Defines when to stop evaluating the active period, must conform to RFC3339.
+                    type: string
               activePeriod:
                 type: object
-                timezone: # Timezone to be used for the startCron field, must conform with the IANA Time Zone database (e.g. America/New_York).
-                  type: string
-                startCron:  # Cron expression defining when to start applying the policy. All TZ/CRON_TZ specification within startCron will be rejected, please use the timezone field above to specify a timezone. Must conform with UNIX CRON syntax.
-                  type: string
-                duration: # The length of time the policy should be applied for (e.g. 2h45m).
-                  type: string
-            {{- include "fleetautoscaler.policy" (dict "includeChainPolicy" false) | indent 12 }} # Defines which policy to apply during the active period. Required.
+                nullable: true
+                properties:
+                  timezone: # Timezone to be used for the startCron field, must conform with the IANA Time Zone database (e.g. America/New_York).
+                    type: string
+                  startCron:  # Cron expression defining when to start applying the policy. All TZ/CRON_TZ specification within startCron will be rejected, please use the timezone field above to specify a timezone. Must conform with UNIX CRON syntax.
+                    type: string
+                  duration: # The length of time the policy should be applied for (e.g. 2h45m).
+                    type: string
+          {{- include "fleetautoscaler.policy" (dict "includeChainPolicy" false) | indent 10 }} # Defines which policy to apply during the active period. Required.
     {{- end }}
 {{- end }}

pkg/apis/autoscaling/v1/fleetautoscaler.go

@@ -16,10 +16,15 @@ package v1
 
 import (
 	"crypto/x509"
+	"errors"
+	"fmt"
 	"net/url"
+	"strings"
+	"time"
 
 	agonesv1 "agones.dev/agones/pkg/apis/agones/v1"
 	"agones.dev/agones/pkg/util/runtime"
+	"github.com/robfig/cron/v3"
 	admregv1 "k8s.io/api/admissionregistration/v1"
 	apimachineryvalidation "k8s.io/apimachinery/pkg/api/validation"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -82,6 +87,11 @@ type FleetAutoscalerPolicy struct {
 	// List policy config params. Present only if FleetAutoscalerPolicyType = List.
 	// +optional
 	List *ListPolicy `json:"list,omitempty"`
+	// [Stage:Dev]
+	// [FeatureFlag:ScheduledAutoscaler]
+	// Chain policy config params. Present only if FleetAutoscalerPolicyType = Chain.
+	// +optional
+	Chain ChainPolicy `json:"chain,omitempty"`
 }
 
 // FleetAutoscalerPolicyType is the policy for autoscaling
@@ -118,6 +128,11 @@ const (
 	// ListPolicyType is for List based fleet autoscaling
 	// nolint:revive // Linter contains comment doesn't start with ListPolicyType
 	ListPolicyType FleetAutoscalerPolicyType = "List"
+	// [Stage:Dev]
+	// [FeatureFlag:ScheduledAutoscaler]
+	// ChainPolicyType is for Chain based fleet autoscaling
+	// nolint:revive // Linter contains comment doesn't start with ChainPolicyType
+	ChainPolicyType FleetAutoscalerPolicyType = "Chain"
 	// FixedIntervalSyncType is a simple fixed interval based strategy for trigger autoscaling
 	FixedIntervalSyncType FleetAutoscalerSyncType = "FixedInterval"
 
@@ -195,6 +210,61 @@ type ListPolicy struct {
 	BufferSize intstr.IntOrString `json:"bufferSize"`
 }
 
+// Between defines the time period that the policy is eligible to be applied.
+type Between struct {
+	// Start is the datetime that the policy is eligible to be applied.
+	// This field must conform to RFC3339 format. If this field not set or is in the past, the policy is eligible to be applied
+	// as soon as the fleet autoscaler is running.
+	Start string `json:"start"`
+
+	// End is the datetime that the policy is no longer eligible to be applied.
+	// This field must conform to RFC3339 format. If not set, the policy is always eligible to be applied, after the start time above.
+	End string `json:"end"`
+}
+
+// ActivePeriod defines the time period that the policy is applied.
+type ActivePeriod struct {
+	// Timezone to be used for the startCron field. If not set, startCron is defaulted to the UTC timezone.
+	Timezone string `json:"timezone"`
+
+	// StartCron defines when the policy should be applied.
+	// If not set, the policy is always to be applied within the start and end time.
+	// This field must conform to UNIX cron syntax.
+	StartCron string `json:"startCron"`
+
+	// Duration is the length of time that the policy is applied.
+	// If not set, the duration is indefinite.
+	// A duration string is a possibly signed sequence of decimal numbers,
+	// (e.g. "300ms", "-1.5h" or "2h45m").
+	// The representation limits the largest representable duration to approximately 290 years.
+	// Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
+	Duration string `json:"duration"`
+}
+
+// Schedule defines when the policy should be applied.
+type Schedule struct {
+	// Between defines the time period that the policy is eligible to be applied.
+	Between Between `json:"between"`
+
+	// ActivePeriod defines the time period that the policy is applied.
+	ActivePeriod ActivePeriod `json:"activePeriod"`
+}
+
+// ChainEntry defines a single entry in the ChainPolicy.
+type ChainEntry struct {
+	// ID is the unique identifier for a ChainEntry. If not set the identifier will be set to the index of chain entry.
+	ID string `json:"id"`
+
+	// Schedule defines when the policy is applied.
+	Schedule Schedule `json:"schedule"`
+
+	// Policy is the name of the policy to be applied. Required field.
+	Policy FleetAutoscalerPolicy `json:"policy"`
+}
+
+// ChainPolicy controls the desired behavior of the Chain autoscaler policy.
+type ChainPolicy []ChainEntry
+
 // FixedIntervalSync controls the desired behavior of the fixed interval based sync.
 type FixedIntervalSync struct {
 	// Seconds defines how often we run fleet autoscaling in seconds
@@ -258,23 +328,32 @@ type FleetAutoscaleReview struct {
 
 // Validate validates the FleetAutoscaler scaling settings
 func (fas *FleetAutoscaler) Validate() field.ErrorList {
+	allErrs := fas.Spec.Policy.ValidatePolicy(field.NewPath("spec", "policy"))
+
+	if fas.Spec.Sync != nil {
+		allErrs = append(allErrs, fas.Spec.Sync.FixedInterval.ValidateFixedIntervalSync(field.NewPath("spec", "sync", "fixedInterval"))...)
+	}
+	return allErrs
+}
+
+// ValidatePolicy validates a FleetAutoscalerPolicy's settings.
+func (f *FleetAutoscalerPolicy) ValidatePolicy(fldPath *field.Path) field.ErrorList {
 	var allErrs field.ErrorList
-	switch fas.Spec.Policy.Type {
+	switch f.Type {
 	case BufferPolicyType:
-		allErrs = fas.Spec.Policy.Buffer.ValidateBufferPolicy(field.NewPath("spec", "policy", "buffer"))
+		allErrs = f.Buffer.ValidateBufferPolicy(fldPath.Child("buffer"))
 
 	case WebhookPolicyType:
-		allErrs = fas.Spec.Policy.Webhook.ValidateWebhookPolicy(field.NewPath("spec", "policy", "webhook"))
+		allErrs = f.Webhook.ValidateWebhookPolicy(fldPath.Child("webhook"))
 
 	case CounterPolicyType:
-		allErrs = fas.Spec.Policy.Counter.ValidateCounterPolicy(field.NewPath("spec", "policy", "counter"))
+		allErrs = f.Counter.ValidateCounterPolicy(fldPath.Child("counter"))
 
 	case ListPolicyType:
-		allErrs = fas.Spec.Policy.List.ValidateListPolicy(field.NewPath("spec", "policy", "list"))
-	}
+		allErrs = f.List.ValidateListPolicy(fldPath.Child("list"))
 
-	if fas.Spec.Sync != nil {
-		allErrs = append(allErrs, fas.Spec.Sync.FixedInterval.ValidateFixedIntervalSync(field.NewPath("spec", "sync", "fixedInterval"))...)
+	case ChainPolicyType:
+		allErrs = f.Chain.ValidateChainPolicy(fldPath.Child("chain"))
 	}
 	return allErrs
 }
@@ -423,6 +502,85 @@ func (l *ListPolicy) ValidateListPolicy(fldPath *field.Path) field.ErrorList {
 	return allErrs
 }
 
+// ValidateChainPolicy validates the FleetAutoscaler Chain policy settings.
+func (c *ChainPolicy) ValidateChainPolicy(fldPath *field.Path) field.ErrorList {
+	var allErrs field.ErrorList
+	if c == nil {
+		return append(allErrs, field.Required(fldPath, "chain policy config params are missing"))
+	}
+	if !runtime.FeatureEnabled(runtime.FeatureScheduledAutoscaler) {
+		return append(allErrs, field.Forbidden(fldPath, "feature ScheduledAutoscaler must be enabled"))
+	}
+	seenIDs := make(map[string]bool)
+	for i, entry := range *c {
+
+		// Ensure that all IDs are unique
+		if seenIDs[entry.ID] {
+			allErrs = append(allErrs, field.Invalid(fldPath, entry.ID, "id of chain entry must be unique"))
+		} else {
+			seenIDs[entry.ID] = true
+		}
+
+		var startTime time.Time
+		var startErr error
+		if entry.Schedule.Between.Start != "" {
+			// If start time is not a valid RFC3339 formatted datetime, append an error
+			startTime, startErr = time.Parse(time.RFC3339, entry.Schedule.Between.Start)
+			if startErr != nil {
+				allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("schedule").Child("between").Child("start"), entry.Schedule.Between.Start, fmt.Sprintf("invalid start time: %s", startErr)))
+			}
+		}
+		if entry.Schedule.Between.End != "" {
+			// If end time is not a valid RFC3339 formatted datetime, append an error
+			endTime, endErr := time.Parse(time.RFC3339, entry.Schedule.Between.End)
+			if endErr != nil {
+				allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("schedule").Child("between").Child("end"), entry.Schedule.Between.End, fmt.Sprintf("invalid end time: %s", endErr)))
+			} else if endTime.Before(time.Now()) {
+				allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("schedule").Child("between").Child("end"), entry.Schedule.Between.End, "end time must be after the current time"))
+				endErr = errors.New("end time before current time")
+			}
+			// Check if the end time is before the start time
+			if (!startTime.IsZero() && startErr == nil) && endErr == nil {
+				if endTime.Before(startTime) {
+					allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("schedule").Child("between"), entry.Schedule.Between, "start time must be before end time"))
+				}
+			}
+		}
+
+		// Validate the active period timezone (empty string defaults to UTC).
+		if _, err := time.LoadLocation(entry.Schedule.ActivePeriod.Timezone); err != nil {
+			allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("schedule").Child("activePeriod").Child("timezone"), entry.Schedule.ActivePeriod.Timezone, fmt.Sprintf("invalid timezone: %s", err)))
+		}
+		if entry.Schedule.ActivePeriod.StartCron != "" {
+			// If startCron is not a valid cron expression, append an error
+			if _, err := cron.ParseStandard(entry.Schedule.ActivePeriod.StartCron); err != nil {
+				allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("schedule").Child("activePeriod").Child("startCron"), entry.Schedule.ActivePeriod.StartCron, fmt.Sprintf("invalid startCron: %s", err)))
+			}
+			// If the cron expression contains a CRON_TZ or TZ specification, append an error
+			if strings.Contains(entry.Schedule.ActivePeriod.StartCron, "TZ") {
+				allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("schedule").Child("activePeriod").Child("startCron"), entry.Schedule.ActivePeriod.StartCron, "CRON_TZ or TZ used in start is not supported, please use the .schedule.timezone field to specify a timezone"))
+			}
+		}
+		if entry.Schedule.ActivePeriod.Duration != "" {
+			// If the duration is not valid duration format, append an error
+			if _, err := time.ParseDuration(entry.Schedule.ActivePeriod.Duration); err != nil {
+				allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("schedule").Child("activePeriod").Child("duration"), entry.Schedule.ActivePeriod.Duration, fmt.Sprintf("invalid duration: %s", err)))
+			}
+		}
+		// Validate that the chain entry has a policy
+		if entry.Policy.Type == "" {
+			allErrs = append(allErrs, field.Required(fldPath.Index(i).Child("policy"), "policy type is missing"))
+		}
+		// Ensure the chain entry's policy is not a chain policy (to avoid nested policies)
+		if entry.Policy.Chain != nil {
+			allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("policy"), entry.Policy.Type, "chain policy cannot be used in chain policy"))
+		}
+		// Validate the chain entry's policy
+		allErrs = append(allErrs, entry.Policy.ValidatePolicy(fldPath.Index(i).Child("policy"))...)
+	}
+	return allErrs
+}
+
 // ValidateFixedIntervalSync validates the FixedIntervalSync settings
 func (i *FixedIntervalSync) ValidateFixedIntervalSync(fldPath *field.Path) field.ErrorList {
 	var allErrs field.ErrorList