Enable RpaasInstance shutting down using Shutdown flag

api/v1alpha1/rpaasinstance_types.go

@@ -134,6 +134,12 @@ type RpaasInstanceSpec struct {
 	// +optional
 	// +kubebuilder:default:=false
 	Suspend *bool `json:"suspend,omitempty"`
+
+	// Shutdown flag tells whether controller should scale down Nginx instances.
+	// Any assosciated HorizontalPodAutoscaler is remove/created when this flag is toggled.
+	// +optional
+	// +kubebuilder:default:=false
+	Shutdown bool `json:"shutdown,omitempty"`
 }
 
 type DynamicCertificates struct {

config/crd/bases/extensions.tsuru.io_rpaasflavors.yaml

@@ -6633,6 +6633,12 @@ spec:
                           Defaults to true.
                         type: boolean
                     type: object
+                  shutdown:
+                    default: false
+                    description: Shutdown flag tells whether controller should scale
+                      down Nginx instances. Any assosciated HorizontalPodAutoscaler
+                      is remove/created when this flag is toggled.
+                    type: boolean
                   suspend:
                     default: false
                     description: Suspend flag tells whether controller should suspend

config/crd/bases/extensions.tsuru.io_rpaasinstances.yaml

@@ -6381,6 +6381,12 @@ spec:
                       true.
                     type: boolean
                 type: object
+              shutdown:
+                default: false
+                description: Shutdown flag tells whether controller should scale down
+                  Nginx instances. Any assosciated HorizontalPodAutoscaler is remove/created
+                  when this flag is toggled.
+                type: boolean
               suspend:
                 default: false
                 description: Suspend flag tells whether controller should suspend

controllers/controller.go

@@ -583,7 +583,7 @@ func (r *RpaasInstanceReconciler) reconcileHPA(ctx context.Context, instance *v1
 	var observed autoscalingv2.HorizontalPodAutoscaler
 	err = r.Client.Get(ctx, types.NamespacedName{Name: desired.Name, Namespace: desired.Namespace}, &observed)
 	if k8sErrors.IsNotFound(err) {
-		if !isAutoscaleEnabled(instance.Spec.Autoscale) {
+		if !isAutoscaleEnabled(&instance.Spec) {
 			logger.V(4).Info("Skipping HorizontalPodAutoscaler reconciliation: both HPA resource and desired RpaasAutoscaleSpec not found")
 			return cleanedKeda, nil
 		}
@@ -605,7 +605,7 @@ func (r *RpaasInstanceReconciler) reconcileHPA(ctx context.Context, instance *v1
 
 	logger = logger.WithValues("HorizontalPodAutoscaler", types.NamespacedName{Name: observed.Name, Namespace: observed.Namespace})
 
-	if !isAutoscaleEnabled(instance.Spec.Autoscale) {
+	if !isAutoscaleEnabled(&instance.Spec) {
 		logger.V(4).Info("Deleting HorizontalPodAutoscaler resource")
 		if err = r.Client.Delete(ctx, &observed); err != nil {
 			logger.Error(err, "Unable to delete the HorizontalPodAutoscaler resource")
@@ -664,7 +664,7 @@ func (r *RpaasInstanceReconciler) reconcileKEDA(ctx context.Context, instance *v
 	var observed kedav1alpha1.ScaledObject
 	err = r.Client.Get(ctx, types.NamespacedName{Name: desired.Name, Namespace: desired.Namespace}, &observed)
 	if k8sErrors.IsNotFound(err) {
-		if !isAutoscaleEnabled(instance.Spec.Autoscale) {
+		if !isAutoscaleEnabled(&instance.Spec) {
 			return false, nil // nothing to do
 		}
 
@@ -679,7 +679,7 @@ func (r *RpaasInstanceReconciler) reconcileKEDA(ctx context.Context, instance *v
 		return false, err
 	}
 
-	if !isAutoscaleEnabled(instance.Spec.Autoscale) {
+	if !isAutoscaleEnabled(&instance.Spec) {
 		err = r.Client.Delete(ctx, &observed)
 		if err != nil {
 			return false, err
@@ -699,12 +699,16 @@ func (r *RpaasInstanceReconciler) reconcileKEDA(ctx context.Context, instance *v
 	return true, nil
 }
 
-func isAutoscaleEnabled(a *v1alpha1.RpaasInstanceAutoscaleSpec) bool {
+func isAutoscaleValid(a *v1alpha1.RpaasInstanceAutoscaleSpec) bool {
 	return a != nil &&
 		(a.MinReplicas != nil && a.MaxReplicas > 0) &&
 		(a.TargetCPUUtilizationPercentage != nil || a.TargetMemoryUtilizationPercentage != nil || a.TargetRequestsPerSecond != nil || len(a.Schedules) > 0)
 }
 
+func isAutoscaleEnabled(instance *v1alpha1.RpaasInstanceSpec) bool {
+	return !instance.Shutdown && isAutoscaleValid(instance.Autoscale)
+}
+
 func newKEDAScaledObject(instance *v1alpha1.RpaasInstance, nginx *nginxv1alpha1.Nginx) (*kedav1alpha1.ScaledObject, error) {
 	var triggers []kedav1alpha1.ScaleTriggers
 	if instance.Spec.Autoscale != nil && instance.Spec.Autoscale.TargetCPUUtilizationPercentage != nil {
@@ -1186,7 +1190,11 @@ func newNginx(instanceMergedWithFlavors *v1alpha1.RpaasInstance, plan *v1alpha1.
 	}
 
 	replicas := instanceMergedWithFlavors.Spec.Replicas
-	if isAutoscaleEnabled(instanceMergedWithFlavors.Spec.Autoscale) {
+	if shutdown := instanceMergedWithFlavors.Spec.Shutdown; shutdown {
+		*replicas = 0
+	}
+
+	if isAutoscaleEnabled(&instanceMergedWithFlavors.Spec) {
 		// NOTE: we should avoid changing the number of replicas as it's managed by HPA.
 		replicas = nil
 	}

controllers/controller_test.go

@@ -114,6 +114,18 @@ func Test_newNginx(t *testing.T) {
 			},
 		},
 
+		"with Shutdown enabled": {
+			instance: func(i *v1alpha1.RpaasInstance) *v1alpha1.RpaasInstance {
+				i.Spec.Replicas = func(n int32) *int32 { return &n }(8)
+				i.Spec.Shutdown = true
+				return i
+			},
+			expected: func(n *nginxv1alpha1.Nginx) *nginxv1alpha1.Nginx {
+				n.Spec.Replicas = func(n int32) *int32 { return &n }(0)
+				return n
+			},
+		},
+
 		"with load balancer": {
 			instance: func(i *v1alpha1.RpaasInstance) *v1alpha1.RpaasInstance {
 				i.Spec.Service = &nginxv1alpha1.NginxService{
@@ -249,6 +261,88 @@ func Test_newNginx(t *testing.T) {
 	}
 }
 
+func Test_isAutoscaleValid(t *testing.T) {
+	tests := map[string]struct {
+		isValid   bool
+		autoscale v1alpha1.RpaasInstanceAutoscaleSpec
+	}{
+		"Invalid null autoscale": {
+			isValid:   false,
+			autoscale: v1alpha1.RpaasInstanceAutoscaleSpec{},
+		},
+
+		"Invalid minReplicas is greater than maxReplicas": {
+			isValid: false,
+			autoscale: v1alpha1.RpaasInstanceAutoscaleSpec{
+				MinReplicas: func(n int32) *int32 { return &n }(5),
+				MaxReplicas: 1,
+			},
+		},
+
+		"Valid autoscale": {
+			isValid: true,
+			autoscale: v1alpha1.RpaasInstanceAutoscaleSpec{
+				MaxReplicas:                    8,
+				MinReplicas:                    func(n int32) *int32 { return &n }(2),
+				TargetCPUUtilizationPercentage: func(n int32) *int32 { return &n }(90),
+			},
+		},
+	}
+
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			got := isAutoscaleValid(&tt.autoscale)
+			assert.Equal(t, tt.isValid, got)
+		})
+	}
+}
+
+func Test_isAutoscaleEnabled(t *testing.T) {
+	tests := map[string]struct {
+		isEnabled    bool
+		instanceSpec v1alpha1.RpaasInstanceSpec
+	}{
+		"Disabled autoscale by invalid spec": {
+			isEnabled: false,
+			instanceSpec: v1alpha1.RpaasInstanceSpec{
+				Shutdown:  false,
+				Autoscale: &v1alpha1.RpaasInstanceAutoscaleSpec{},
+			},
+		},
+
+		"Disabled autoscale by shutdown": {
+			isEnabled: false,
+			instanceSpec: v1alpha1.RpaasInstanceSpec{
+				Shutdown: true,
+				Autoscale: &v1alpha1.RpaasInstanceAutoscaleSpec{
+					MaxReplicas:                    8,
+					MinReplicas:                    func(n int32) *int32 { return &n }(2),
+					TargetCPUUtilizationPercentage: func(n int32) *int32 { return &n }(90),
+				},
+			},
+		},
+
+		"Enabled autoscale": {
+			isEnabled: true,
+			instanceSpec: v1alpha1.RpaasInstanceSpec{
+				Shutdown: false,
+				Autoscale: &v1alpha1.RpaasInstanceAutoscaleSpec{
+					MaxReplicas:                    4,
+					MinReplicas:                    func(n int32) *int32 { return &n }(2),
+					TargetCPUUtilizationPercentage: func(n int32) *int32 { return &n }(70),
+				},
+			},
+		},
+	}
+
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			got := isAutoscaleEnabled(&tt.instanceSpec)
+			assert.Equal(t, tt.isEnabled, got)
+		})
+	}
+}
+
 func Test_mergePlans(t *testing.T) {
 	tests := []struct {
 		base     v1alpha1.RpaasPlanSpec