Store the gate results on the deployer.

Healthchecks are passing.

Author: bigkevmcd

api/v1alpha1/kustomizationautodeployer_types.go

@@ -22,7 +22,7 @@ import (
 )
 
 const (
-	// GatesClosedReason is set when further deployments can't continue because
+	// GatesClosedReason is set when no commits will be applied because
 	// the gates are currently closed.
 	GatesClosedReason string = "GatesClosed"
 
@@ -39,6 +39,10 @@ const (
 	RevisionsErrorReason string = "RevisionsError"
 )
 
+// GatesStatus contains a per-Gate, per check state of the configured gates in
+// the auto deployer.
+type GatesStatus map[string]map[string]bool
+
 // HealthCheck is a Gate that fetches a URL and is open if the requests are
 // successful.
 type HealthCheck struct {
@@ -126,6 +130,9 @@ type KustomizationAutoDeployerStatus struct {
 	// Conditions holds the conditions for the KustomizationAutoDeployer.
 	// +optional
 	Conditions []metav1.Condition `json:"conditions,omitempty"`
+
+	// Gates contains the state of the configured gates.
+	Gates GatesStatus `json:"gates,omitempty"`
 }
 
 //+kubebuilder:object:root=true

api/v1alpha1/zz_generated.deepcopy.go

@@ -180,6 +180,13 @@ spec:
                   - type
                   type: object
                 type: array
+              gates:
+                additionalProperties:
+                  additionalProperties:
+                    type: boolean
+                  type: object
+                description: Gates contains the state of the configured gates.
+                type: object
               latestCommit:
                 description: LatestCommit is the latest commit processed by the Kustomization.
                 type: string

config/crd/bases/flux.gitops.pro_kustomizationautodeployers.yaml

@@ -26,13 +26,13 @@ import (
 
 // Check checks the gates defined in the KustomizationAutoDeployer and returns
 // true if all gates are open.
-func Check(ctx context.Context, r *deployerv1.KustomizationAutoDeployer, configuredGates map[string]Gate) (bool, map[string]map[string]bool, error) {
+func Check(ctx context.Context, r *deployerv1.KustomizationAutoDeployer, configuredGates map[string]Gate) (bool, deployerv1.GatesStatus, error) {
 	// Open if no Gates are defined.
 	if len(r.Spec.Gates) == 0 {
 		return true, nil, nil
 	}
 
-	result := map[string]map[string]bool{}
+	result := deployerv1.GatesStatus{}
 	for _, gate := range r.Spec.Gates {
 		checks, err := check(ctx, gate, r, configuredGates)
 		if err != nil {

controllers/gates/check.go

@@ -37,7 +37,7 @@ func TestCheck(t *testing.T) {
 		name     string
 		deployer *deployerv1.KustomizationAutoDeployer
 		open     bool
-		checks   map[string]map[string]bool
+		checks   deployerv1.GatesStatus
 	}{
 		{
 			name:     "no gates should fail open",
@@ -58,7 +58,7 @@ func TestCheck(t *testing.T) {
 				}
 			}),
 			open:   true,
-			checks: map[string]map[string]bool{"within scheduled hours": {"ScheduledGate": true}},
+			checks: deployerv1.GatesStatus{"within scheduled hours": {"ScheduledGate": true}},
 		},
 		{
 			name: "closed gate is closed",
@@ -74,7 +74,7 @@ func TestCheck(t *testing.T) {
 				}
 			}),
 			open:   false,
-			checks: map[string]map[string]bool{"outwith scheduled hours": {"ScheduledGate": false}},
+			checks: deployerv1.GatesStatus{"outwith scheduled hours": {"ScheduledGate": false}},
 		},
 	}
 

controllers/gates/check_test.go

@@ -76,7 +76,7 @@ func (g HealthCheckGate) Check(ctx context.Context, gate *deployerv1.Kustomizati
 }
 
 // Interval returns the time after which to requeue this check.
-func (g HealthCheckGate) Interval(gate *deployerv1.KustomizationGate) time.Duration {
-	return gate.HealthCheck.Interval.Duration
+func (g HealthCheckGate) Interval(gate *deployerv1.KustomizationGate) (time.Duration, error) {
+	return gate.HealthCheck.Interval.Duration, nil
 
 }

controllers/gates/healthcheck/health_check.go

@@ -91,7 +91,7 @@ func TestHealthCheckGate_Interval(t *testing.T) {
 	}
 
 	gen := New(logr.Discard(), nil)
-	if i := gen.Interval(gate); i != time.Minute*5 {
+	if i, _ := gen.Interval(gate); i != time.Minute*5 {
 		t.Fatalf("Interval() got %v, want %v", i, time.Minute*5)
 	}
 }

controllers/gates/healthcheck/health_check_test.go

@@ -40,7 +40,7 @@ type Gate interface {
 	//
 	// A Gate can return an empty time.Duration value if it should not be
 	// rechecked after a period.
-	Interval(*deployerv1.KustomizationGate) time.Duration
+	Interval(*deployerv1.KustomizationGate) (time.Duration, error)
 }
 
 // NoRequeueInterval is a simple default value that can be used to indicate that

controllers/gates/interface.go

@@ -58,15 +58,9 @@ type ScheduledGate struct {
 
 // Check returns true if now is within the the Scheduled gate time duration.
 func (g ScheduledGate) Check(ctx context.Context, gate *deployerv1.KustomizationGate, _ *deployerv1.KustomizationAutoDeployer) (bool, error) {
-	now := g.Clock()
 	// TODO: Logging
-
-	open, err := parseAndMerge(now, gate.Name, "open", gate.Scheduled.Open)
-	if err != nil {
-		return false, err
-	}
-
-	closed, err := parseAndMerge(now, gate.Name, "close", gate.Scheduled.Close)
+	now := g.Clock()
+	open, closed, err := parseScheduledTimes(now, gate.Name, gate.Scheduled)
 	if err != nil {
 		return false, err
 	}
@@ -88,6 +82,34 @@ func parseAndMerge(now time.Time, name, phase, str string) (time.Time, error) {
 }
 
 // Interval returns the time after which to requeue this check.
-func (g ScheduledGate) Interval(gate *deployerv1.KustomizationGate) time.Duration {
-	return time.Minute * 3
+func (g ScheduledGate) Interval(gate *deployerv1.KustomizationGate) (time.Duration, error) {
+	now := g.Clock()
+	open, closed, err := parseScheduledTimes(now, gate.Name, gate.Scheduled)
+	if err != nil {
+		return 0, err
+	}
+
+	if now.Before(open) {
+		return open.Sub(now), nil
+	}
+
+	if now.Before(closed) {
+		return closed.Sub(now), nil
+	}
+
+	return open.Add(time.Hour * 24).Sub(now), nil
+}
+
+func parseScheduledTimes(now time.Time, name string, check *deployerv1.ScheduledCheck) (open time.Time, closed time.Time, err error) {
+	open, err = parseAndMerge(now, name, "open", check.Open)
+	if err != nil {
+		return
+	}
+
+	closed, err = parseAndMerge(now, name, "close", check.Close)
+	if err != nil {
+		return
+	}
+
+	return
 }

controllers/gates/scheduled/scheduled_check.go

@@ -119,8 +119,26 @@ func TestScheduledGate_Check_errors(t *testing.T) {
 }
 
 func TestScheduledGate_Interval(t *testing.T) {
-	// 9am on the 14th May 2023
-	now := time.Date(2023, time.May, 14, 9, 0, 0, 0, time.UTC)
+	intervalTests := []struct {
+		now  time.Time
+		want time.Duration
+	}{
+		{
+			// 09:00 on the 14th May 2023
+			now:  time.Date(2023, time.May, 14, 9, 0, 0, 0, time.UTC),
+			want: time.Hour * 8,
+		},
+		{
+			// 18:00 on the 14th May 2023
+			now:  time.Date(2023, time.May, 14, 18, 0, 0, 0, time.UTC),
+			want: time.Hour * 1,
+		},
+		{
+			// 20:00 on the 14th May 2023
+			now:  time.Date(2023, time.May, 14, 20, 0, 0, 0, time.UTC),
+			want: time.Hour * 21, // 20:00 -> 00:00 + 17:00 = 21h
+		},
+	}
 
 	gate := &deployerv1.KustomizationGate{
 		Name: "testing",
@@ -130,13 +148,22 @@ func TestScheduledGate_Interval(t *testing.T) {
 		},
 	}
 
-	gen := New(logr.Discard(), func(s *ScheduledGate) {
-		s.Clock = func() time.Time {
-			return now
-		}
-	})
+	for _, tt := range intervalTests {
+		t.Run(fmt.Sprintf("%v", tt.now), func(t *testing.T) {
+			gen := New(logr.Discard(), func(s *ScheduledGate) {
+				s.Clock = func() time.Time {
+					return tt.now
+				}
+			})
+
+			i, err := gen.Interval(gate)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-	if i := gen.Interval(gate); i != time.Minute*5 {
-		t.Fatalf("Interval() got %v, want %v", i, time.Minute*5)
+			if i != tt.want {
+				t.Fatalf("Interval() got %v, want %v", i, tt.want)
+			}
+		})
 	}
 }