diff --git a/api/core/v1beta1/config_util.go b/api/core/v1beta1/config_util.go new file mode 100644 index 0000000..fd347ab --- /dev/null +++ b/api/core/v1beta1/config_util.go @@ -0,0 +1,19 @@ +package v1beta1 + +import ( + "fmt" + "reflect" + "sort" +) + +// sortedMapKeys returns the keys of a map value sorted by their string form. +// Go randomizes map iteration order, so config renderers must iterate maps in +// a fixed order to produce byte-identical output (and stable hash annotations) +// across reconciles. +func sortedMapKeys(m reflect.Value) []reflect.Value { + keys := m.MapKeys() + sort.Slice(keys, func(i, j int) bool { + return fmt.Sprintf("%v", keys[i]) < fmt.Sprintf("%v", keys[j]) + }) + return keys +} diff --git a/api/core/v1beta1/connect_config.go b/api/core/v1beta1/connect_config.go index e083b02..142aeaf 100644 --- a/api/core/v1beta1/connect_config.go +++ b/api/core/v1beta1/connect_config.go @@ -203,7 +203,9 @@ func (configStruct *ConnectConfig) GenerateGcfg() (string, error) { var builder strings.Builder // Build an intermediate representation: ordered sections with key-value pairs. - // We use ordered slices to preserve the deterministic output order from reflection. + // Ordered slices preserve the struct field order from reflection. Map-valued + // fields (named sections) are not ordered by reflection, so their keys are + // sorted explicitly below. type sectionEntry struct { name string keys []string // ordered key names (for non-slice values) @@ -233,10 +235,10 @@ func (configStruct *ConnectConfig) GenerateGcfg() (string, error) { // Handle the RPackageRepositories map (named sections) if fieldValue.Kind() == reflect.Map { - iter := sectionStructVals.MapRange() - for iter.Next() { - repoName := iter.Key() - repoValue := iter.Value() + // Iterate in sorted key order: Go randomizes map iteration, and an + // unstable section order would change the configmap hash on every reconcile + for _, repoName := range sortedMapKeys(sectionStructVals) { + repoValue := sectionStructVals.MapIndex(repoName) qualifiedName := fieldName + " \"" + fmt.Sprintf("%v", repoName) + "\"" entry := sectionEntry{ name: qualifiedName, diff --git a/api/core/v1beta1/connect_config_test.go b/api/core/v1beta1/connect_config_test.go index 6b76545..746063c 100644 --- a/api/core/v1beta1/connect_config_test.go +++ b/api/core/v1beta1/connect_config_test.go @@ -316,3 +316,34 @@ func TestConnectConfig_AdditionalConfigEmpty(t *testing.T) { require.Nil(t, err) require.Contains(t, str, "Address = some-address.com") } + +// Go randomizes map iteration order, so named sections rendered from a map must +// be sorted. Otherwise the configmap content (and its hash annotation) changes +// between reconciles and the Deployment rolls repeatedly. +func TestConnectConfig_GenerateGcfgRepositoriesDeterministic(t *testing.T) { + c := ConnectConfig{ + Server: &ConnectServerConfig{ + Address: "some-address.com", + }, + RPackageRepository: map[string]RPackageRepositoryConfig{ + "RSPM": {Url: "https://packages.example.com/cran/latest"}, + "CRAN": {Url: "https://cran.example.com/latest"}, + "Internal": {Url: "https://internal.example.com/cran/latest"}, + }, + } + + first := requireStableRender(t, func() map[string]string { + str, err := c.GenerateGcfg() + require.Nil(t, err) + return map[string]string{"gcfg": str} + })["gcfg"] + + requireInOrder(t, first, + `[RPackageRepository "CRAN"]`, + `[RPackageRepository "Internal"]`, + `[RPackageRepository "RSPM"]`) + + // Each section keeps its own Url directly beneath its header + require.Contains(t, first, "[RPackageRepository \"CRAN\"]\nUrl = https://cran.example.com/latest\n") + require.Contains(t, first, "[RPackageRepository \"RSPM\"]\nUrl = https://packages.example.com/cran/latest\n") +} diff --git a/api/core/v1beta1/workbench_config.go b/api/core/v1beta1/workbench_config.go index 8f7d615..b850518 100644 --- a/api/core/v1beta1/workbench_config.go +++ b/api/core/v1beta1/workbench_config.go @@ -58,11 +58,9 @@ func (w *WorkbenchSecretIniConfig) GenerateConfigMap() map[string]string { sessionValues := reflect.Indirect(fieldValue) if fieldValue.Kind() == reflect.Map { - iter := sessionValues.MapRange() - - for iter.Next() { - key := iter.Key() - value := reflect.Indirect(iter.Value()) + // Iterate in sorted key order so the rendered output (and its hash) is stable + for _, key := range sortedMapKeys(sessionValues) { + value := reflect.Indirect(sessionValues.MapIndex(key)) builder.WriteString("\n[" + fmt.Sprintf("%v", key) + "]\n") @@ -469,11 +467,9 @@ func (w *WorkbenchProfilesConfig) GenerateConfigMap() map[string]string { profiles := reflect.Indirect(fieldValue) - iter := profiles.MapRange() - - for iter.Next() { - profileName := iter.Key() - profileValues := iter.Value() + // Iterate in sorted key order so the rendered output (and its hash) is stable + for _, profileName := range sortedMapKeys(profiles) { + profileValues := profiles.MapIndex(profileName) builder.WriteString("\n[" + fmt.Sprintf("%v", profileName) + "]\n") @@ -622,12 +618,10 @@ func (w *WorkbenchIniConfig) GenerateConfigMap() map[string]string { } } } else { - // Default handling for other map fields - iter := sectionStructVals.MapRange() - - for iter.Next() { - key := iter.Key() - value := reflect.Indirect(iter.Value()) + // Default handling for other map fields, in sorted key order so the + // rendered output (and its hash) is stable + for _, key := range sortedMapKeys(sectionStructVals) { + value := reflect.Indirect(sectionStructVals.MapIndex(key)) builder.WriteString("\n[" + fmt.Sprintf("%v", key) + "]\n") @@ -799,17 +793,13 @@ func (w *WorkbenchConfig) GenerateSupervisorConfigmap(ctx context.Context) (map[ programs := reflect.Indirect(fieldValue) - iter := programs.MapRange() - - for iter.Next() { - fileName := fmt.Sprintf("%v", iter.Key()) - programMap := iter.Value() - - programIter := programMap.MapRange() + // Iterate in sorted key order so the rendered output is stable + for _, fileKey := range sortedMapKeys(programs) { + fileName := fmt.Sprintf("%v", fileKey) + programMap := programs.MapIndex(fileKey) - for programIter.Next() { - programName := programIter.Key() - programValues := reflect.Indirect(programIter.Value()) + for _, programName := range sortedMapKeys(programMap) { + programValues := reflect.Indirect(programMap.MapIndex(programName)) builder.WriteString("[program:" + fmt.Sprintf("%v", programName) + "]\n") diff --git a/api/core/v1beta1/workbench_config_test.go b/api/core/v1beta1/workbench_config_test.go index 8fb8127..10d3d18 100644 --- a/api/core/v1beta1/workbench_config_test.go +++ b/api/core/v1beta1/workbench_config_test.go @@ -1218,3 +1218,111 @@ func TestWorkbenchConfig_ForceAdminUiEnabled(t *testing.T) { require.Nil(t, err) require.Contains(t, res["rserver.conf"], "force-admin-ui-enabled=0\n") } + +// requireStableRender renders a config many times and asserts the output never +// changes. Go randomizes map iteration order, so any renderer that walks a map +// without sorting would eventually produce a different result here. +func requireStableRender(t *testing.T, render func() map[string]string) map[string]string { + t.Helper() + first := render() + for i := 0; i < 50; i++ { + require.Equal(t, first, render(), "rendered output changed on iteration %d", i) + } + return first +} + +// requireInOrder asserts that each needle appears in s, in the given order. +func requireInOrder(t *testing.T, s string, needles ...string) { + t.Helper() + prev := -1 + for _, n := range needles { + idx := strings.Index(s, n) + require.NotEqual(t, -1, idx, "expected %q in output", n) + require.Greater(t, idx, prev, "expected %q to appear after the previous entry", n) + prev = idx + } +} + +func TestWorkbenchSecretConfig_DatabricksDeterministic(t *testing.T) { + w := WorkbenchSecretConfig{ + WorkbenchSecretIniConfig: WorkbenchSecretIniConfig{ + Databricks: map[string]*WorkbenchDatabricksConfig{ + "workspace-c": {Name: "Workspace C", Url: "https://c.example.com", ClientId: "client-c"}, + "workspace-a": {Name: "Workspace A", Url: "https://a.example.com", ClientId: "client-a"}, + "workspace-b": {Name: "Workspace B", Url: "https://b.example.com", ClientId: "client-b"}, + }, + }, + } + + out := requireStableRender(t, func() map[string]string { + data, err := w.GenerateSecretData() + require.Nil(t, err) + return data + }) + + conf := out["databricks.conf"] + requireInOrder(t, conf, "[workspace-a]", "[workspace-b]", "[workspace-c]") + require.Contains(t, conf, "\n[workspace-a]\nname=Workspace A\nurl=https://a.example.com\nclient-id=client-a\n") +} + +func TestWorkbenchIniConfig_DatabricksDeterministic(t *testing.T) { + w := WorkbenchConfig{ + WorkbenchIniConfig: WorkbenchIniConfig{ + Databricks: map[string]*WorkbenchDatabricksConfig{ + "workspace-b": {Name: "Workspace B", Url: "https://b.example.com"}, + "workspace-a": {Name: "Workspace A", Url: "https://a.example.com"}, + "workspace-c": {Name: "Workspace C", Url: "https://c.example.com"}, + }, + }, + } + + out := requireStableRender(t, func() map[string]string { + data, err := w.GenerateConfigmap() + require.Nil(t, err) + return data + }) + + requireInOrder(t, out["databricks.conf"], "[workspace-a]", "[workspace-b]", "[workspace-c]") +} + +func TestWorkbenchProfilesConfig_Deterministic(t *testing.T) { + w := WorkbenchConfig{ + WorkbenchProfilesConfig: WorkbenchProfilesConfig{ + LauncherKubernetesProfiles: map[string]WorkbenchLauncherKubernetesProfilesConfigSection{ + "user-a": {DefaultCpus: "2"}, + "*": {DefaultCpus: "1"}, + "@group-b": {DefaultCpus: "4"}, + }, + }, + } + + out := requireStableRender(t, func() map[string]string { + data, err := w.GenerateConfigmap() + require.Nil(t, err) + return data + }) + + requireInOrder(t, out["launcher.kubernetes.profiles.conf"], "[*]", "[@group-b]", "[user-a]") +} + +func TestWorkbenchConfig_GenerateSupervisorConfigmap_Deterministic(t *testing.T) { + wbc := WorkbenchConfig{ + SupervisordIniConfig: SupervisordIniConfig{ + Programs: map[string]map[string]*SupervisordProgramConfig{ + "programs.conf": { + "program-c": {Command: "/bin/c", User: "rserver"}, + "program-a": {Command: "/bin/a", User: "rserver"}, + "program-b": {Command: "/bin/b", User: "rserver"}, + }, + }, + }, + } + + out := requireStableRender(t, func() map[string]string { + cm, err := wbc.GenerateSupervisorConfigmap(context.TODO()) + require.Nil(t, err) + return cm + }) + + requireInOrder(t, out["programs.conf"], "[program:program-a]", "[program:program-b]", "[program:program-c]") +}