add static and non static handling, change log file, re-add tests

Author: nammn

changelog/20250806_breaking_changing_container_setup_of_static_architecture.md renamed to changelog/20250806_other_changing_container_setup_of_static_architecture.md

@@ -1,6 +1,6 @@
 ---
 title: Changing container setup of static architecture
-kind: breaking
+kind: other
 date: 2025-08-06
 ---
 

controllers/operator/mongodbshardedcluster_controller_test.go

@@ -1719,6 +1719,7 @@ func computeSingleClusterShardOverridesFromDistribution(shardOverridesDistributi
 }
 
 type SingleClusterShardedScalingTestCase struct {
+	name         string
 	scalingSteps []SingleClusterShardedScalingStep
 }
 
@@ -1791,6 +1792,88 @@ func SingleClusterShardedScalingWithOverridesTestCase(t *testing.T, tc SingleClu
 	}
 }
 
+func TestSingleClusterShardedScalingWithOverrides(t *testing.T) {
+	scDefaultName := test.SCBuilderDefaultName + "-"
+	testCases := []SingleClusterShardedScalingTestCase{
+		{
+			name: "Basic sample test",
+			scalingSteps: []SingleClusterShardedScalingStep{
+				{
+					name:                 "Initial scaling",
+					shardCount:           3,
+					mongodsPerShardCount: 3,
+					shardOverrides: map[string]int{
+						scDefaultName + "0": 5,
+					},
+					expectedShardDistribution: []int{
+						5,
+						3,
+						3,
+					},
+				},
+				{
+					name:                 "Scale up mongodsPerShard",
+					shardCount:           3,
+					mongodsPerShardCount: 5,
+					shardOverrides: map[string]int{
+						scDefaultName + "0": 5,
+					},
+					expectedShardDistribution: []int{
+						5,
+						5,
+						5,
+					},
+				},
+			},
+		},
+		{
+			// This operation works in unit test only
+			// In e2e tests, the operator is waiting for uncreated hostnames to be ready
+			name: "Scale overrides up and down",
+			scalingSteps: []SingleClusterShardedScalingStep{
+				{
+					name:                 "Initial deployment",
+					shardCount:           4,
+					mongodsPerShardCount: 2,
+					shardOverrides: map[string]int{
+						scDefaultName + "0": 3,
+						scDefaultName + "1": 3,
+						scDefaultName + "3": 2,
+					},
+					expectedShardDistribution: []int{
+						3,
+						3,
+						2, // Not overridden
+						2,
+					},
+				},
+				{
+					name:                 "Scale overrides",
+					shardCount:           4,
+					mongodsPerShardCount: 2,
+					shardOverrides: map[string]int{
+						scDefaultName + "0": 2, // Scaled down
+						scDefaultName + "1": 2, // Scaled down
+						scDefaultName + "3": 3, // Scaled up
+					},
+					expectedShardDistribution: []int{
+						2, // Scaled down
+						2, // Scaled down
+						2, // Not overridden
+						3, // Scaled up
+					},
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			SingleClusterShardedScalingWithOverridesTestCase(t, tc)
+		})
+	}
+}
+
 func generateHostsWithDistributionSingleCluster(stsName string, namespace string, memberCount int, clusterDomain string, externalClusterDomain string) ([]string, []string) {
 	var hosts []string
 	var podNames []string

lib/sonar/builders/docker.py

@@ -209,7 +209,7 @@ def inner_docker_push(should_raise=False):
     # Instead of doing the hack here, we should instead either:
     # - make sonar aware of context images
     # - move the logic out of sonar to pipeline.py to all the places where we build context images
-    if "-context" in tag and image_exists(registry, tag) and "ecr" not in registry:
+    if "-context" in tag and image_exists(registry, tag):
         logger.info(f"Image: {tag} in registry: {registry} already exists skipping pushing it")
     else:
         logger.info("Image does not exist remotely or is not a context image, pushing it!")

mongodb-community-operator/controllers/construct/build_statefulset_test.go

@@ -65,7 +65,7 @@ func TestManagedSecurityContext(t *testing.T) {
 
 func TestMongod_Container(t *testing.T) {
 	const mongodbImageMock = "fake-mongodbImage"
-	c := container.New(mongodbContainer(mongodbImageMock, []corev1.VolumeMount{}, mdbv1.NewMongodConfiguration()))
+	c := container.New(mongodbContainer(mongodbImageMock, []corev1.VolumeMount{}, mdbv1.NewMongodConfiguration(), false))
 
 	t.Run("Has correct Env vars", func(t *testing.T) {
 		assert.Len(t, c.Env, 1)

mongodb-community-operator/controllers/construct/mongodbstatefulset.go

@@ -244,7 +244,7 @@ func BuildMongoDBReplicaSetStatefulSetModificationFunction(mdb MongoDBStatefulSe
 				podtemplatespec.WithVolume(keyFileVolume),
 				podtemplatespec.WithServiceAccount(mongodbDatabaseServiceAccountName),
 				podtemplatespec.WithContainer(AgentName, mongodbAgentContainer(mdb.AutomationConfigSecretName(), mongodbAgentVolumeMounts, agentLogLevel, agentLogFile, agentMaxLogFileDurationHours, agentImage)),
-				podtemplatespec.WithContainer(MongodbName, mongodbContainer(mongodbImage, mongodVolumeMounts, mdb.GetMongodConfiguration())),
+				podtemplatespec.WithContainer(MongodbName, mongodbContainer(mongodbImage, mongodVolumeMounts, mdb.GetMongodConfiguration(), !withInitContainers)),
 				withStaticContainerModification,
 				upgradeInitContainer,
 				readinessInitContainer,
@@ -400,24 +400,64 @@ func readinessProbeInit(volumeMount []corev1.VolumeMount, readinessProbeImage st
 	)
 }
 
-func mongodbContainer(mongodbImage string, volumeMounts []corev1.VolumeMount, additionalMongoDBConfig mdbv1.MongodConfiguration) container.Modification {
-	filePath := additionalMongoDBConfig.GetDBDataDir() + "/" + automationMongodConfFileName
-	mongoDbCommand := fmt.Sprintf(`
-# Signal handler for graceful shutdown
+// buildSignalHandling returns the signal handling setup for static architecture
+func buildSignalHandling() string {
+	return fmt.Sprintf(`
+# Signal handler for graceful shutdown in shared PID namespace
 cleanup() {
+	# Important! Keep this in sync with DefaultPodTerminationPeriodSeconds constant from constants.go
+	termination_timeout_seconds=%d
+
 	echo "MongoDB container received SIGTERM, shutting down gracefully..."
+
 	if [ -n "$MONGOD_PID" ] && kill -0 "$MONGOD_PID" 2>/dev/null; then
 		echo "Sending SIGTERM to mongod process $MONGOD_PID"
-		kill -TERM "$MONGOD_PID"
-		wait "$MONGOD_PID"
+		kill -15 "$MONGOD_PID"
+
+		echo "Waiting until mongod process is shutdown. Note, that if mongod process fails to shutdown in the time specified by the 'terminationGracePeriodSeconds' property (default ${termination_timeout_seconds} seconds) then the container will be killed by Kubernetes."
+
+		# Use the same robust waiting mechanism as agent-launcher-lib.sh
+		# We cannot use 'wait' for processes started in background, use spinning loop
+		while [ -e "/proc/${MONGOD_PID}" ]; do
+			sleep 0.1
+		done
+
 		echo "mongod process has exited"
 	fi
+
+	echo "MongoDB container shutdown complete"
 	exit 0
 }
 
-# Set up signal handler
+# Set up signal handler for static architecture
 trap cleanup SIGTERM
+`, util.DefaultPodTerminationPeriodSeconds)
+}
+
+// buildMongodExecution returns the mongod execution command based on architecture
+// in static we run /pause as pid1 and we need to ensure to redirect sigterm to the mongod process
+func buildMongodExecution(filePath string, isStatic bool) string {
+	if isStatic {
+		return fmt.Sprintf(`mongod -f %s &
+MONGOD_PID=$!
+echo "Started mongod with PID $MONGOD_PID"
 
+# Wait for mongod to finish
+wait "$MONGOD_PID"`, filePath)
+	}
+	return fmt.Sprintf("exec mongod -f %s", filePath)
+}
+
+// buildMongodbCommand constructs the complete MongoDB container command
+func buildMongodbCommand(filePath string, isStatic bool) string {
+	signalHandling := ""
+	if isStatic {
+		signalHandling = buildSignalHandling()
+	}
+
+	mongodExec := buildMongodExecution(filePath, isStatic)
+
+	return fmt.Sprintf(`%s
 if [ -e "/hooks/version-upgrade" ]; then
 	#run post-start hook to handle version changes (if exists)
     /hooks/version-upgrade
@@ -437,13 +477,13 @@ sleep 15
 
 # start mongod with this configuration
 echo "Starting mongod..."
-mongod -f %s &
-MONGOD_PID=$!
-echo "Started mongod with PID $MONGOD_PID"
+%s
+`, signalHandling, filePath, keyfileFilePath, mongodExec)
+}
 
-# Wait for mongod to finish
-wait "$MONGOD_PID"
-`, filePath, keyfileFilePath, filePath)
+func mongodbContainer(mongodbImage string, volumeMounts []corev1.VolumeMount, additionalMongoDBConfig mdbv1.MongodConfiguration, isStatic bool) container.Modification {
+	filePath := additionalMongoDBConfig.GetDBDataDir() + "/" + automationMongodConfFileName
+	mongoDbCommand := buildMongodbCommand(filePath, isStatic)
 
 	containerCommand := []string{
 		"/bin/sh",

mongodb-community-operator/controllers/construct/mongodbstatefulset_test.go

@@ -7,6 +7,7 @@ import (
 
 	corev1 "k8s.io/api/core/v1"
 
+	mdbv1 "github.com/mongodb/mongodb-kubernetes/mongodb-community-operator/api/v1"
 	"github.com/mongodb/mongodb-kubernetes/mongodb-community-operator/pkg/readiness/config"
 )
 
@@ -98,3 +99,56 @@ func TestCollectEnvVars(t *testing.T) {
 		})
 	}
 }
+
+func TestMongodbContainer_SignalHandling(t *testing.T) {
+	tests := []struct {
+		name     string
+		isStatic bool
+		wantExec bool
+	}{
+		{
+			name:     "Non-static architecture uses exec mongod",
+			isStatic: false,
+			wantExec: true,
+		},
+		{
+			name:     "Static architecture uses trap and background mongod",
+			isStatic: true,
+			wantExec: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mongodConfig := mdbv1.NewMongodConfiguration()
+			mongodConfig.SetOption("storage.dbPath", "/data")
+
+			containerMod := mongodbContainer("test-image", []corev1.VolumeMount{}, mongodConfig, tt.isStatic)
+
+			testContainer := &corev1.Container{}
+			containerMod(testContainer)
+
+			assert.Len(t, testContainer.Command, 3)
+			assert.Equal(t, "/bin/sh", testContainer.Command[0])
+			assert.Equal(t, "-c", testContainer.Command[1])
+			commandScript := testContainer.Command[2]
+
+			if tt.isStatic {
+				assert.Contains(t, commandScript, "trap cleanup SIGTERM", "Static architecture should include signal trap")
+				assert.Contains(t, commandScript, "cleanup() {", "Static architecture should include cleanup function")
+				assert.Contains(t, commandScript, "mongod -f /data/automation-mongod.conf &", "Static architecture should run mongod in background")
+				assert.Contains(t, commandScript, "wait \"$MONGOD_PID\"", "Static architecture should wait for mongod process")
+				assert.Contains(t, commandScript, "termination_timeout_seconds", "Static architecture should include timeout configuration")
+				assert.Contains(t, commandScript, "while [ -e \"/proc/${MONGOD_PID}\" ]", "Static architecture should include robust process waiting")
+				assert.Contains(t, commandScript, "kill -15 \"$MONGOD_PID\"", "Static architecture should send SIGTERM to mongod")
+			} else {
+				assert.NotContains(t, commandScript, "trap cleanup SIGTERM", "Non-static architecture should not include signal trap")
+				assert.NotContains(t, commandScript, "cleanup() {", "Non-static architecture should not include cleanup function")
+				assert.Contains(t, commandScript, "exec mongod -f /data/automation-mongod.conf", "Non-static architecture should exec mongod")
+			}
+
+			assert.Contains(t, commandScript, "Waiting for config and keyfile files to be created by the agent", "Should wait for agent files")
+			assert.Contains(t, commandScript, "Starting mongod...", "Should start mongod")
+		})
+	}
+}