Merge pull request gocrane#796 from qmhu/ana-conversion

Support v0.5 version compatiablilty

cmd/craned/app/manager.go

@@ -113,7 +113,12 @@ func Run(ctx context.Context, opts *options.Options) error {
 		return err
 	}
 
-	if err := mgr.AddHealthzCheck("ping", healthz.Ping); err != nil {
+	if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil {
+		klog.ErrorS(err, "failed to add health check endpoint")
+		return err
+	}
+
+	if err := mgr.AddReadyzCheck("readyz", healthz.Ping); err != nil {
 		klog.ErrorS(err, "failed to add health check endpoint")
 		return err
 	}

pkg/controller/analytics/analytics_controller.go

@@ -546,8 +546,11 @@ func setReadyCondition(status *analysisv1alph1.AnalyticsStatus, conditionStatus
 func ConvertToRecommendationRule(analytics *analysisv1alph1.Analytics) *analysisv1alph1.RecommendationRule {
 	recommendationRule := &analysisv1alph1.RecommendationRule{}
 	recommendationRule.Name = analytics.Name
+	if recommendationRule.Annotations == nil {
+		recommendationRule.Annotations = map[string]string{}
+	}
+	recommendationRule.Annotations[known.AnalyticsConversionAnnotation] = string(analytics.UID)
 	recommendationRule.Spec.ResourceSelectors = analytics.Spec.ResourceSelectors
-	// todo: make sure the conversion is right after recommendation refactor
 	recommendationRule.Spec.Recommenders = []analysisv1alph1.Recommender{{Name: string(analytics.Spec.Type)}}
 	if analytics.Namespace == known.CraneSystemNamespace {
 		recommendationRule.Spec.NamespaceSelector.Any = true
@@ -560,6 +563,11 @@ func ConvertToRecommendationRule(analytics *analysisv1alph1.Analytics) *analysis
 		recommendationRule.Spec.RunInterval = (time.Duration(*analytics.Spec.CompletionStrategy.PeriodSeconds) * time.Second).String()
 	}
 
+	recommendationRule.Status = analysisv1alph1.RecommendationRuleStatus{
+		LastUpdateTime:  analytics.Status.LastUpdateTime,
+		Recommendations: analytics.Status.Recommendations,
+	}
+
 	return recommendationRule
 }
 
@@ -572,8 +580,10 @@ func UpsertRecommendationRule(recommendationRule *analysisv1alph1.Recommendation
 		return err
 	}
 
-	if !reflect.DeepEqual(recommendationRule.Spec, recommendationRuleExist.Spec) {
+	if !reflect.DeepEqual(recommendationRule.Spec, recommendationRuleExist.Spec) ||
+		reflect.DeepEqual(recommendationRule.Annotations, recommendationRuleExist.Annotations) {
 		recommendationRuleExist.Spec = recommendationRule.Spec
+		recommendationRuleExist.Annotations = recommendationRule.Annotations
 		return client.Update(context.TODO(), recommendationRuleExist)
 	}
 

pkg/controller/recommendation/recommendation_rule_controller.go

@@ -159,6 +159,12 @@ func (c *RecommendationRuleController) doReconcile(ctx context.Context, recommen
 	opts := []client.ListOption{
 		client.MatchingLabels(map[string]string{known.RecommendationRuleUidLabel: string(recommendationRule.UID)}),
 	}
+	if convert, uid := IsConvertFromAnalytics(recommendationRule); convert {
+		opts = []client.ListOption{
+			client.MatchingLabels(map[string]string{known.AnalyticsUidLabel: uid}),
+		}
+	}
+
 	err = c.Client.List(ctx, &currRecommendations, opts...)
 	if err != nil {
 		c.Recorder.Event(recommendationRule, corev1.EventTypeWarning, "FailedSelectResource", err.Error())
@@ -380,6 +386,9 @@ func CreateRecommendationObject(recommendationRule *analysisv1alph1.Recommendati
 	if id.Namespace != "" {
 		namespace = id.Namespace
 	}
+	if convert, _ := IsConvertFromAnalytics(recommendationRule); convert {
+		namespace = known.CraneSystemNamespace
+	}
 
 	recommendation := &analysisv1alph1.Recommendation{
 		ObjectMeta: metav1.ObjectMeta{
@@ -398,6 +407,9 @@ func CreateRecommendationObject(recommendationRule *analysisv1alph1.Recommendati
 	labels := map[string]string{}
 	labels[known.RecommendationRuleNameLabel] = recommendationRule.Name
 	labels[known.RecommendationRuleUidLabel] = string(recommendationRule.UID)
+	if convert, uid := IsConvertFromAnalytics(recommendationRule); convert {
+		labels[known.AnalyticsUidLabel] = uid
+	}
 	labels[known.RecommendationRuleRecommenderLabel] = recommenderName
 	labels[known.RecommendationRuleTargetKindLabel] = target.Kind
 	labels[known.RecommendationRuleTargetVersionLabel] = target.GroupVersionKind().Version
@@ -485,3 +497,13 @@ func executeMission(ctx context.Context, wg *sync.WaitGroup, recommenderMgr reco
 		mission.APIVersion = recommendation.APIVersion
 	}
 }
+
+func IsConvertFromAnalytics(recommendationRule *analysisv1alph1.RecommendationRule) (bool, string) {
+	if recommendationRule.Annotations != nil {
+		if uid, exist := recommendationRule.Annotations[known.AnalyticsConversionAnnotation]; exist {
+			return true, uid
+		}
+	}
+
+	return false, ""
+}

pkg/controller/recommendation/recommendation_trigger_controller.go

@@ -56,7 +56,7 @@ func (c *RecommendationTriggerController) Reconcile(ctx context.Context, req ctr
 
 	recommendationRuleRef := utils.GetRecommendationRuleOwnerReference(recommendation)
 	if recommendationRuleRef == nil {
-		klog.Warningf("cannot found referred recommendation rule %s/%s", recommendation.Namespace, recommendationRuleRef.Name)
+		klog.Warning("cannot found referred recommendation rule")
 		return ctrl.Result{}, nil
 	}
 

pkg/known/annotation.go

@@ -5,6 +5,7 @@ const (
 	ReplicasRecommendationValueAnnotation = "analysis.crane.io/replicas-recommendation"
 	ResourceRecommendationValueAnnotation = "analysis.crane.io/resource-recommendation"
 	RunNumberAnnotation                   = "analysis.crane.io/run-number"
+	AnalyticsConversionAnnotation         = "analysis.crane.io/analytics-conversion"
 )
 
 const (

pkg/metrics/metric_collector.go

@@ -10,13 +10,15 @@ import (
 
 	"github.com/prometheus/client_golang/prometheus"
 	"k8s.io/apimachinery/pkg/api/meta"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
 	"k8s.io/client-go/scale"
 	"k8s.io/klog/v2"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	autoscalingapi "github.com/gocrane/api/autoscaling/v1alpha1"
 	predictionapi "github.com/gocrane/api/prediction/v1alpha1"
 
+	"github.com/gocrane/crane/pkg/features"
 	. "github.com/gocrane/crane/pkg/metricprovider"
 )
 
@@ -79,42 +81,44 @@ func (c *CraneMetricCollector) Describe(ch chan<- *prometheus.Desc) {
 }
 
 func (c *CraneMetricCollector) Collect(ch chan<- prometheus.Metric) {
-	var ehpaList autoscalingapi.EffectiveHorizontalPodAutoscalerList
-	err := c.List(context.TODO(), &ehpaList)
-	if err != nil {
-		klog.Errorf("Failed to list ehpa: %v", err)
-	}
-	var predictionMetrics []PredictionMetric
-	for _, ehpa := range ehpaList.Items {
-		namespace := ehpa.Namespace
-		if ehpa.Spec.Prediction != nil {
-			var tsp predictionapi.TimeSeriesPrediction
-			tspName := "ehpa-" + ehpa.Name
+	if utilfeature.DefaultFeatureGate.Enabled(features.CraneAutoscaling) {
+		var ehpaList autoscalingapi.EffectiveHorizontalPodAutoscalerList
+		err := c.List(context.TODO(), &ehpaList)
+		if err != nil {
+			klog.Errorf("Failed to list ehpa: %v", err)
+		}
+		var predictionMetrics []PredictionMetric
+		for _, ehpa := range ehpaList.Items {
+			namespace := ehpa.Namespace
+			if ehpa.Spec.Prediction != nil {
+				var tsp predictionapi.TimeSeriesPrediction
+				tspName := "ehpa-" + ehpa.Name
 
-			err := c.Get(context.TODO(), client.ObjectKey{Namespace: namespace, Name: tspName}, &tsp)
-			if err != nil {
-				klog.Errorf("Failed to get tsp: %v", err)
-				return
-			}
-			metricListTsp := c.getMetricsTsp(&tsp)
-			for _, metric := range metricListTsp {
-				if MetricContains(predictionMetrics, metric) {
-					continue
+				err := c.Get(context.TODO(), client.ObjectKey{Namespace: namespace, Name: tspName}, &tsp)
+				if err != nil {
+					klog.Errorf("Failed to get tsp: %v", err)
+					return
 				}
+				metricListTsp := c.getMetricsTsp(&tsp)
+				for _, metric := range metricListTsp {
+					if MetricContains(predictionMetrics, metric) {
+						continue
+					}
 
-				ch <- prometheus.NewMetricWithTimestamp(metric.Timestamp, prometheus.MustNewConstMetric(metric.Desc, prometheus.GaugeValue, metric.MetricValue, metric.TargetKind, metric.TargetName, metric.TargetNamespace, metric.ResourceIdentifier, metric.Algorithm))
-				predictionMetrics = append(predictionMetrics, metric)
+					ch <- prometheus.NewMetricWithTimestamp(metric.Timestamp, prometheus.MustNewConstMetric(metric.Desc, prometheus.GaugeValue, metric.MetricValue, metric.TargetKind, metric.TargetName, metric.TargetNamespace, metric.ResourceIdentifier, metric.Algorithm))
+					predictionMetrics = append(predictionMetrics, metric)
+				}
 			}
-		}
 
-		if ehpa.Spec.Crons != nil {
-			metricCron, err := c.getMetricsCron(&ehpa)
-			if err != nil {
-				klog.Errorf("Failed to get metricCron: %v", err)
-				return
-			}
+			if ehpa.Spec.Crons != nil {
+				metricCron, err := c.getMetricsCron(&ehpa)
+				if err != nil {
+					klog.Errorf("Failed to get metricCron: %v", err)
+					return
+				}
 
-			ch <- metricCron
+				ch <- metricCron
+			}
 		}
 	}
 }