fix: resolve v1.2 parameter metadata

Author: shanshanying

pkg/cmd/cluster/config_ops_test.go

@@ -21,6 +21,7 @@ package cluster
 
 import (
 	"bytes"
+	"context"
 	"io"
 
 	. "github.com/onsi/ginkgo/v2"
@@ -83,6 +84,8 @@ var _ = Describe("reconfigure test", func() {
 		configmap := testapps.NewCustomizedObj("resources/mysql-config-template.yaml", &corev1.ConfigMap{}, testapps.WithNamespace(ns), testapps.WithName(testing.FakeMysqlTemplateName))
 		componentConfig := testapps.NewConfigMap(ns, cfgcore.GetComponentCfgName(clusterName, statefulCompName, configSpecName), setConfigMapData("my.cnf", ""))
 		objs := []runtime.Object{configmap, componentConfig}
+		pd := testing.FakeParameterDefinition()
+		pd.Status = parametersv1alpha1.ParametersDefinitionStatus{Phase: parametersv1alpha1.PDAvailablePhase}
 		ttf, ops := NewFakeOperationsOptions(ns, clusterName, objs...)
 		o := &configOpsOptions{
 			// nil cannot be set to a map struct in CueLang, so init the map of KeyValues.
@@ -95,7 +98,7 @@ var _ = Describe("reconfigure test", func() {
 		o.clientSet = kbfakeclient.NewSimpleClientset(
 			testing.FakeCluster(clusterName, ns),
 			testing.FakeCompDef(),
-			testing.FakeParameterDefinition(),
+			pd,
 			testing.FakeParameterConfigRenderer(),
 		)
 		defer ttf.Cleanup()
@@ -141,6 +144,135 @@ var _ = Describe("reconfigure test", func() {
 		Expect(supportsDynamicReload(&parametersv1alpha1.ParametersDefinitionSpec{}, nil)).Should(BeFalse())
 	})
 
+	It("discovers direct ParametersDefinitions without legacy ParamConfigRenderer", func() {
+		pd := testing.FakeParameterDefinition()
+		pd.Name = "direct-pd"
+		pd.Spec.ComponentDef = testing.CompDefName
+		pd.Spec.TemplateName = "mysql-config"
+		pd.Spec.FileName = "my.cnf"
+		pd.Spec.FileFormatConfig = &parametersv1alpha1.FileFormatConfig{Format: parametersv1alpha1.Ini}
+		pd.Status = parametersv1alpha1.ParametersDefinitionStatus{Phase: parametersv1alpha1.PDAvailablePhase}
+
+		rctx, err := generateReconfigureContext(
+			context.TODO(),
+			kbfakeclient.NewSimpleClientset(
+				testing.FakeCluster(clusterName, testing.Namespace),
+				testing.FakeCompDef(),
+				pd,
+			),
+			clusterName,
+			testing.ComponentName,
+			testing.Namespace,
+		)
+
+		Expect(err).Should(Succeed())
+		Expect(rctx.ParametersDefs).Should(HaveLen(1))
+		Expect(rctx.ParametersDefs[0].Name).Should(Equal("direct-pd"))
+		Expect(configDescriptions(rctx)).Should(Equal([]parametersv1alpha1.ComponentConfigDescription{{
+			Name:         "my.cnf",
+			TemplateName: "mysql-config",
+			FileFormatConfig: &parametersv1alpha1.FileFormatConfig{
+				Format: parametersv1alpha1.Ini,
+			},
+		}}))
+		Expect(rctx.ConfigRender).Should(BeNil())
+	})
+
+	It("keeps legacy ParamConfigRenderer discovery with component definition pattern matching", func() {
+		pd := testing.FakeParameterDefinition()
+		pd.Status = parametersv1alpha1.ParametersDefinitionStatus{Phase: parametersv1alpha1.PDAvailablePhase}
+		pcr := testing.FakeParameterConfigRenderer()
+		pcr.Spec.ComponentDef = "fake-component"
+
+		rctx, err := generateReconfigureContext(
+			context.TODO(),
+			kbfakeclient.NewSimpleClientset(
+				testing.FakeCluster(clusterName, testing.Namespace),
+				testing.FakeCompDef(),
+				pd,
+				pcr,
+			),
+			clusterName,
+			testing.ComponentName,
+			testing.Namespace,
+		)
+
+		Expect(err).Should(Succeed())
+		Expect(rctx.ParametersDefs).Should(HaveLen(1))
+		Expect(rctx.ParametersDefs[0].Name).Should(Equal("test-pd"))
+		Expect(configDescriptions(rctx)).Should(Equal(pcr.Spec.Configs))
+		Expect(rctx.ConfigRender).ShouldNot(BeNil())
+	})
+
+	It("merges direct ParametersDefinitions with legacy ParamConfigRenderer for uncovered files", func() {
+		directPD := testing.FakeParameterDefinition()
+		directPD.Name = "direct-pd"
+		directPD.Spec.ComponentDef = testing.CompDefName
+		directPD.Spec.TemplateName = "mysql-config"
+		directPD.Spec.FileName = "my.cnf"
+		directPD.Spec.FileFormatConfig = &parametersv1alpha1.FileFormatConfig{Format: parametersv1alpha1.Ini}
+		directPD.Status = parametersv1alpha1.ParametersDefinitionStatus{Phase: parametersv1alpha1.PDAvailablePhase}
+
+		legacyPD := testing.FakeParameterDefinition()
+		legacyPD.Name = "legacy-pd"
+		legacyPD.Spec.FileName = "log.conf"
+		legacyPD.Status = parametersv1alpha1.ParametersDefinitionStatus{Phase: parametersv1alpha1.PDAvailablePhase}
+
+		pcr := testing.FakeParameterConfigRenderer()
+		pcr.Spec.ParametersDefs = []string{"direct-pd", "legacy-pd"}
+		pcr.Spec.Configs = []parametersv1alpha1.ComponentConfigDescription{
+			{
+				Name:         "my.cnf",
+				TemplateName: "legacy-mysql-config",
+				FileFormatConfig: &parametersv1alpha1.FileFormatConfig{
+					Format: parametersv1alpha1.Properties,
+				},
+			},
+			{
+				Name:         "log.conf",
+				TemplateName: "log-config",
+				FileFormatConfig: &parametersv1alpha1.FileFormatConfig{
+					Format: parametersv1alpha1.Properties,
+				},
+			},
+		}
+
+		rctx, err := generateReconfigureContext(
+			context.TODO(),
+			kbfakeclient.NewSimpleClientset(
+				testing.FakeCluster(clusterName, testing.Namespace),
+				testing.FakeCompDef(),
+				directPD,
+				legacyPD,
+				pcr,
+			),
+			clusterName,
+			testing.ComponentName,
+			testing.Namespace,
+		)
+
+		Expect(err).Should(Succeed())
+		Expect(rctx.ParametersDefs).Should(HaveLen(2))
+		Expect(rctx.ParametersDefs[0].Name).Should(Equal("direct-pd"))
+		Expect(rctx.ParametersDefs[1].Name).Should(Equal("legacy-pd"))
+		Expect(configDescriptions(rctx)).Should(Equal([]parametersv1alpha1.ComponentConfigDescription{
+			{
+				Name:         "my.cnf",
+				TemplateName: "mysql-config",
+				FileFormatConfig: &parametersv1alpha1.FileFormatConfig{
+					Format: parametersv1alpha1.Ini,
+				},
+			},
+			{
+				Name:         "log.conf",
+				TemplateName: "log-config",
+				FileFormatConfig: &parametersv1alpha1.FileFormatConfig{
+					Format: parametersv1alpha1.Properties,
+				},
+			},
+		}))
+	})
+
 	It("uses config template name to transform typed parameter values", func() {
 		value := "true"
 		params := map[string]*parametersv1alpha1.ParametersInFile{

pkg/cmd/cluster/config_wrapper.go

@@ -23,10 +23,13 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"slices"
+	"strings"
 
 	kbappsv1 "github.com/apecloud/kubeblocks/apis/apps/v1"
 	parametersv1alpha1 "github.com/apecloud/kubeblocks/apis/parameters/v1alpha1"
 	"github.com/apecloud/kubeblocks/pkg/client/clientset/versioned"
+	"github.com/apecloud/kubeblocks/pkg/controller/component"
 	"github.com/apecloud/kubeblocks/pkg/generics"
 	configctrl "github.com/apecloud/kubeblocks/pkg/parameters"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -40,6 +43,7 @@ type ReconfigureContext struct {
 	Cluster        *kbappsv1.Cluster
 	Cmpd           *kbappsv1.ComponentDefinition
 	ConfigRender   *parametersv1alpha1.ParamConfigRenderer
+	ConfigDescs    []parametersv1alpha1.ComponentConfigDescription
 	ParametersDefs []*parametersv1alpha1.ParametersDefinition
 
 	CompName string
@@ -60,7 +64,7 @@ func (w *ReconfigureWrapper) ConfigSpecName() string {
 		return w.configFileKey
 	}
 	file := w.ConfigFile()
-	if file != "" && w.rctx.ConfigRender != nil {
+	if file != "" {
 		config := configctrl.GetComponentConfigDescription(configDescriptions(w.rctx), file)
 		if config != nil {
 			return config.TemplateName
@@ -77,14 +81,20 @@ func (w *ReconfigureWrapper) ConfigFile() string {
 	if w.configFileKey != "" {
 		return w.configFileKey
 	}
-	if w.rctx.ConfigRender != nil && len(w.rctx.ConfigRender.Spec.Configs) > 0 {
-		return w.rctx.ConfigRender.Spec.Configs[0].Name
+	if configDescs := configDescriptions(w.rctx); len(configDescs) > 0 {
+		return configDescs[0].Name
 	}
 	return ""
 }
 
 func configDescriptions(rctx *ReconfigureContext) []parametersv1alpha1.ComponentConfigDescription {
-	if rctx == nil || rctx.ConfigRender == nil {
+	if rctx == nil {
+		return nil
+	}
+	if len(rctx.ConfigDescs) > 0 {
+		return rctx.ConfigDescs
+	}
+	if rctx.ConfigRender == nil {
 		return nil
 	}
 	return rctx.ConfigRender.Spec.Configs
@@ -191,20 +201,117 @@ func resolveComponentDefObj(ctx context.Context, client versioned.Interface, clu
 }
 
 func resolveCmpdParametersDefs(rctx *ReconfigureContext) error {
-	configRender, err := resolveComponentConfigRender(rctx, rctx.Cmpd)
+	configDescs, paramsDefs, coveredFiles, err := resolveDirectParametersDefs(rctx)
 	if err != nil {
 		return err
 	}
-	if configRender == nil || len(configRender.Spec.ParametersDefs) == 0 {
-		return nil
+
+	configRender, err := resolveComponentConfigRender(rctx, rctx.Cmpd)
+	if err != nil {
+		return err
 	}
 	rctx.ConfigRender = configRender
-	for _, defName := range configRender.Spec.ParametersDefs {
-		pd, err := rctx.Client.ParametersV1alpha1().ParametersDefinitions().Get(rctx.Context, defName, metav1.GetOptions{})
+	if configRender != nil {
+		legacyConfigFiles := make(map[string]struct{}, len(configRender.Spec.Configs))
+		for _, configDesc := range configRender.Spec.Configs {
+			if _, ok := coveredFiles[configDesc.Name]; ok {
+				continue
+			}
+			configDescs = append(configDescs, configDesc)
+			legacyConfigFiles[configDesc.Name] = struct{}{}
+		}
+		for _, defName := range configRender.Spec.ParametersDefs {
+			pd, err := rctx.Client.ParametersV1alpha1().ParametersDefinitions().Get(rctx.Context, defName, metav1.GetOptions{})
+			if err != nil {
+				return err
+			}
+			if pd.Status.Phase != parametersv1alpha1.PDAvailablePhase {
+				return fmt.Errorf("the referenced ParametersDefinition is unavailable: %s", pd.Name)
+			}
+			if _, ok := legacyConfigFiles[pd.Spec.FileName]; ok {
+				paramsDefs = append(paramsDefs, pd)
+			}
+		}
+	}
+
+	rctx.ConfigDescs = configDescs
+	rctx.ParametersDefs = paramsDefs
+	return nil
+}
+
+func resolveDirectParametersDefs(rctx *ReconfigureContext) ([]parametersv1alpha1.ComponentConfigDescription, []*parametersv1alpha1.ParametersDefinition, map[string]struct{}, error) {
+	paramsDefList, err := rctx.Client.ParametersV1alpha1().ParametersDefinitions().List(rctx.Context, metav1.ListOptions{})
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	slices.SortFunc(paramsDefList.Items, func(a, b parametersv1alpha1.ParametersDefinition) int {
+		if cmp := strings.Compare(b.Spec.ComponentDef, a.Spec.ComponentDef); cmp != 0 {
+			return cmp
+		}
+		if cmp := strings.Compare(a.Spec.TemplateName, b.Spec.TemplateName); cmp != 0 {
+			return cmp
+		}
+		if cmp := strings.Compare(a.Spec.FileName, b.Spec.FileName); cmp != 0 {
+			return cmp
+		}
+		return strings.Compare(a.Name, b.Name)
+	})
+
+	var paramsDefs []*parametersv1alpha1.ParametersDefinition
+	configDescs := make([]parametersv1alpha1.ComponentConfigDescription, 0, len(paramsDefList.Items))
+	coveredFiles := make(map[string]struct{})
+	for i := range paramsDefList.Items {
+		paramsDef := &paramsDefList.Items[i]
+		matched, err := matchParametersDefinition(rctx.Cmpd, paramsDef)
 		if err != nil {
-			return err
+			return nil, nil, nil, err
+		}
+		if !matched {
+			continue
 		}
-		rctx.ParametersDefs = append(rctx.ParametersDefs, pd)
+		if paramsDef.Status.Phase != parametersv1alpha1.PDAvailablePhase {
+			return nil, nil, nil, fmt.Errorf("the referenced ParametersDefinition is unavailable: %s", paramsDef.Name)
+		}
+		if err := validateMatchedParametersDefinition(paramsDef); err != nil {
+			return nil, nil, nil, err
+		}
+		if _, ok := coveredFiles[paramsDef.Spec.FileName]; ok {
+			return nil, nil, nil, fmt.Errorf("config file[%s] has been defined in other parametersdefinition", paramsDef.Spec.FileName)
+		}
+		coveredFiles[paramsDef.Spec.FileName] = struct{}{}
+		paramsDefs = append(paramsDefs, paramsDef)
+		configDescs = append(configDescs, parametersv1alpha1.ComponentConfigDescription{
+			Name:             paramsDef.Spec.FileName,
+			TemplateName:     paramsDef.Spec.TemplateName,
+			FileFormatConfig: paramsDef.Spec.FileFormatConfig.DeepCopy(),
+		})
+	}
+	return configDescs, paramsDefs, coveredFiles, nil
+}
+
+func matchParametersDefinition(cmpd *kbappsv1.ComponentDefinition, paramsDef *parametersv1alpha1.ParametersDefinition) (bool, error) {
+	if cmpd == nil || paramsDef == nil {
+		return false, nil
+	}
+	pattern := paramsDef.Spec.ComponentDef
+	if pattern == "" {
+		return false, nil
+	}
+	if !component.PrefixOrRegexMatched(cmpd.Name, pattern) {
+		return false, nil
+	}
+	return paramsDef.Spec.ServiceVersion == "" || paramsDef.Spec.ServiceVersion == cmpd.Spec.ServiceVersion, nil
+}
+
+func validateMatchedParametersDefinition(paramsDef *parametersv1alpha1.ParametersDefinition) error {
+	if paramsDef.Spec.TemplateName == "" {
+		return fmt.Errorf("ParametersDefinition[%s] misses templateName", paramsDef.Name)
+	}
+	if paramsDef.Spec.FileName == "" {
+		return fmt.Errorf("ParametersDefinition[%s] misses fileName", paramsDef.Name)
+	}
+	if paramsDef.Spec.FileFormatConfig == nil {
+		return fmt.Errorf("ParametersDefinition[%s] misses fileFormatConfig", paramsDef.Name)
 	}
 	return nil
 }
@@ -217,7 +324,7 @@ func resolveComponentConfigRender(rctx *ReconfigureContext, cmpd *kbappsv1.Compo
 
 	var prcs []parametersv1alpha1.ParamConfigRenderer
 	for i, item := range pcrList.Items {
-		if item.Spec.ComponentDef != cmpd.Name {
+		if !component.PrefixOrRegexMatched(cmpd.Name, item.Spec.ComponentDef) {
 			continue
 		}
 		if item.Spec.ServiceVersion == "" || item.Spec.ServiceVersion == cmpd.Spec.ServiceVersion {