From 7f5d8c2d2e9d0ea5f4372bd264aa45ea175c41f5 Mon Sep 17 00:00:00 2001 From: Steve Nolen Date: Thu, 1 Oct 2026 09:58:33 -0400 Subject: [PATCH 1/2] fix: sort map keys when rendering Workbench and Connect config Go randomizes map iteration order. Several config renderers walked maps with reflect.MapRange() and wrote named sections in iteration order, so the same spec could render to different bytes on each reconcile. The configmap-sha and secret-sha pod template annotations then changed and rolled the Deployment. Iterate map keys in sorted order in Connect GenerateGcfg (RPackageRepository sections) and in the Workbench renderers for databricks.conf (secret and deprecated configmap field), launcher.kubernetes.profiles.conf and supervisord programs. Output is otherwise unchanged. Add tests that render each config 50 times and assert identical, sorted output. --- api/core/v1beta1/connect_config.go | 12 ++- api/core/v1beta1/connect_config_test.go | 39 ++++++++ api/core/v1beta1/workbench_config.go | 54 +++++------ api/core/v1beta1/workbench_config_test.go | 108 ++++++++++++++++++++++ 4 files changed, 182 insertions(+), 31 deletions(-) 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..107e41f 100644 --- a/api/core/v1beta1/connect_config_test.go +++ b/api/core/v1beta1/connect_config_test.go @@ -1,6 +1,7 @@ package v1beta1 import ( + "strings" "testing" "github.com/stretchr/testify/require" @@ -316,3 +317,41 @@ 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, err := c.GenerateGcfg() + require.Nil(t, err) + + for i := 0; i < 50; i++ { + str, err := c.GenerateGcfg() + require.Nil(t, err) + require.Equal(t, first, str, "rendered gcfg changed on iteration %d", i) + } + + cranIdx := strings.Index(first, "[RPackageRepository \"CRAN\"]") + internalIdx := strings.Index(first, "[RPackageRepository \"Internal\"]") + rspmIdx := strings.Index(first, "[RPackageRepository \"RSPM\"]") + require.NotEqual(t, -1, cranIdx) + require.NotEqual(t, -1, internalIdx) + require.NotEqual(t, -1, rspmIdx) + require.Less(t, cranIdx, internalIdx) + require.Less(t, internalIdx, rspmIdx) + + // 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..dd2f07c 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() + // 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 iter.Next() { - fileName := fmt.Sprintf("%v", iter.Key()) - programMap := iter.Value() - - programIter := programMap.MapRange() - - 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") @@ -1146,6 +1136,18 @@ type WorkbenchLauncherServerConfig struct { SecureCookieKeyFile string `json:"secure-cookie-key-file,omitempty"` } +// 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 +} + func sliceToString(sliceValue reflect.Value, separator string) string { var arrayString string for k := 0; k < sliceValue.Len(); k++ { 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]") +} From 1449702d06d7b8db94f0b0d2d77f52ac1a2be119 Mon Sep 17 00:00:00 2001 From: Steve Nolen Date: Thu, 1 Oct 2026 15:15:25 -0400 Subject: [PATCH 2/2] refactor: share sortedMapKeys and reuse render test helpers Move sortedMapKeys into config_util.go since both the Workbench and Connect renderers use it, and reuse requireStableRender and requireInOrder in the Connect gcfg ordering test. --- api/core/v1beta1/config_util.go | 19 +++++++++++++++++++ api/core/v1beta1/connect_config_test.go | 22 +++++++--------------- api/core/v1beta1/workbench_config.go | 12 ------------ 3 files changed, 26 insertions(+), 27 deletions(-) create mode 100644 api/core/v1beta1/config_util.go 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_test.go b/api/core/v1beta1/connect_config_test.go index 107e41f..746063c 100644 --- a/api/core/v1beta1/connect_config_test.go +++ b/api/core/v1beta1/connect_config_test.go @@ -1,7 +1,6 @@ package v1beta1 import ( - "strings" "testing" "github.com/stretchr/testify/require" @@ -333,23 +332,16 @@ func TestConnectConfig_GenerateGcfgRepositoriesDeterministic(t *testing.T) { }, } - first, err := c.GenerateGcfg() - require.Nil(t, err) - - for i := 0; i < 50; i++ { + first := requireStableRender(t, func() map[string]string { str, err := c.GenerateGcfg() require.Nil(t, err) - require.Equal(t, first, str, "rendered gcfg changed on iteration %d", i) - } + return map[string]string{"gcfg": str} + })["gcfg"] - cranIdx := strings.Index(first, "[RPackageRepository \"CRAN\"]") - internalIdx := strings.Index(first, "[RPackageRepository \"Internal\"]") - rspmIdx := strings.Index(first, "[RPackageRepository \"RSPM\"]") - require.NotEqual(t, -1, cranIdx) - require.NotEqual(t, -1, internalIdx) - require.NotEqual(t, -1, rspmIdx) - require.Less(t, cranIdx, internalIdx) - require.Less(t, internalIdx, rspmIdx) + 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") diff --git a/api/core/v1beta1/workbench_config.go b/api/core/v1beta1/workbench_config.go index dd2f07c..b850518 100644 --- a/api/core/v1beta1/workbench_config.go +++ b/api/core/v1beta1/workbench_config.go @@ -1136,18 +1136,6 @@ type WorkbenchLauncherServerConfig struct { SecureCookieKeyFile string `json:"secure-cookie-key-file,omitempty"` } -// 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 -} - func sliceToString(sliceValue reflect.Value, separator string) string { var arrayString string for k := 0; k < sliceValue.Len(); k++ {