fix(sandbox): skip wsrep post-start gate for non-Galera single sandboxes

wait_wsrep_after_start runs after every single-sandbox deploy, but it only
returns success when wsrep_ready=ON — which never happens on a plain
MySQL/MariaDB sandbox (no wsrep). It also polls $SBDIR/use (the sandbox
user) before post-grants provisions that user, so it hits "Access denied"
and loops for its full 60s timeout on every non-Galera deploy. The code
already (falsely) labelled it a "no-op on non-Galera".

Gate the script on actual wsrep usage (a wsrep option in MyCnfOptions or a
wsrep arg in StartArgs), so it runs only for Galera/PXC nodes where it
matters. Plain MySQL/MariaDB single deploys no longer pay the 60s delay.

- add sandboxUsesWsrep(SandboxDef) helper
- gate the concurrent execList append and the non-concurrent RunCmd
- TestSandboxUsesWsrep covers wsrep_provider / wsrep_cluster_address /
  wsrep-on, --wsrep-new-cluster, and negative (plain mysql/mariadb) cases

Author: nnosal

sandbox/sandbox.go

@@ -347,6 +347,27 @@ func sbError(reason, format string, args ...interface{}) error {
 	return fmt.Errorf(reason+" "+format, args...)
 }
 
+// sandboxUsesWsrep reports whether the sandbox is configured for Galera/PXC
+// (wsrep). The post-start wait_wsrep_after_start gate only matters for wsrep
+// nodes: on a plain MySQL/MariaDB single sandbox wsrep is never active, so the
+// gate polls the not-yet-provisioned sandbox user for its whole timeout (the
+// helper script returns success only when wsrep_ready=ON, which never happens
+// without wsrep). Skipping it makes the gate a true no-op on non-Galera, as the
+// surrounding log messages already (falsely) claim.
+func sandboxUsesWsrep(sd SandboxDef) bool {
+	for _, opt := range sd.MyCnfOptions {
+		if strings.Contains(opt, "wsrep") {
+			return true
+		}
+	}
+	for _, arg := range sd.StartArgs {
+		if strings.Contains(arg, "wsrep") {
+			return true
+		}
+	}
+	return false
+}
+
 func createSingleSandbox(sandboxDef SandboxDef) (execList []concurrent.ExecutionList, err error) {
 
 	var sandboxDir string
@@ -1058,15 +1079,17 @@ func createSingleSandbox(sandboxDef SandboxDef) (execList []concurrent.Execution
 				}
 			)
 			logger.Printf("Adding after start command to execution list\n")
-			logger.Printf("Adding wait-wsrep command to execution list (no-op on non-Galera)\n")
 			logger.Printf("Adding pre grants command to execution list\n")
 			logger.Printf("Adding load grants command to execution list\n")
 			logger.Printf("Adding post grants command to execution list\n")
 			execList = append(execList, concurrent.ExecutionList{Logger: logger, Priority: 3, Command: eCmdAfterStart})
-			execList = append(execList, concurrent.ExecutionList{Logger: logger, Priority: 4, Command: eCmdWaitWsrep})
 			execList = append(execList, concurrent.ExecutionList{Logger: logger, Priority: 5, Command: eCmdPreGrants})
 			execList = append(execList, concurrent.ExecutionList{Logger: logger, Priority: 6, Command: eCmdLoadGrants})
 			execList = append(execList, concurrent.ExecutionList{Logger: logger, Priority: 7, Command: eCmdPostGrants})
+			if sandboxUsesWsrep(sandboxDef) {
+				logger.Printf("Adding wait-wsrep command to execution list\n")
+				execList = append(execList, concurrent.ExecutionList{Logger: logger, Priority: 4, Command: eCmdWaitWsrep})
+			}
 		}
 	} else {
 		if !sandboxDef.SkipStart {
@@ -1084,8 +1107,10 @@ func createSingleSandbox(sandboxDef SandboxDef) (execList []concurrent.Execution
 			if err != nil {
 				return emptyExecutionList, err
 			}
-			logger.Printf("Running wait-wsrep script (no-op on non-Galera)\n")
-			_, _ = common.RunCmd(path.Join(sandboxDir, globals.ScriptWaitWsrepAfterStart))
+			if sandboxUsesWsrep(sandboxDef) {
+				logger.Printf("Running wait-wsrep script\n")
+				_, _ = common.RunCmd(path.Join(sandboxDir, globals.ScriptWaitWsrepAfterStart))
+			}
 			if sandboxDef.LoadGrants {
 				logger.Printf("Running pre grants script\n")
 				_, err = common.RunCmdWithArgs(path.Join(sandboxDir, globals.ScriptLoadGrants), []string{globals.ScriptPreGrantsSql})

sandbox/sandbox_test.go

@@ -634,7 +634,7 @@ func testCreateReplicationSandbox(t *testing.T) {
 			t.Fatalf("expected replica use script at %s", use)
 		}
 		// RunCmdWithArgs (RunCmd takes only the cmd string)
-		out, err := common.RunCmdWithArgs(use, []string{"-BN", "-e", "SELECT 1;"}); // tests #131 fix: replica must be ready immediately (no sleep) after deploy
+		out, err := common.RunCmdWithArgs(use, []string{"-BN", "-e", "SELECT 1;"}) // tests #131 fix: replica must be ready immediately (no sleep) after deploy
 		if err != nil {
 			t.Fatalf("replica n%s not ready immediately after deploy replication: %v\noutput: %s", n, err, out)
 		}
@@ -713,3 +713,32 @@ func TestCreateSandbox(t *testing.T) {
 	t.Run("expectedFailures", testFailSandboxConditions)
 	t.Run("flavors", testDetectFlavor)
 }
+
+// TestSandboxUsesWsrep checks that the wsrep gate fires only for Galera/PXC
+// (wsrep-enabled) sandboxes. Plain MySQL/MariaDB single sandboxes carry no
+// wsrep option, so the post-start wait_wsrep_after_start script must be skipped
+// for them — otherwise it polls the not-yet-provisioned sandbox user until its
+// timeout (wsrep_ready is never ON without wsrep).
+func TestSandboxUsesWsrep(t *testing.T) {
+	cases := []struct {
+		name string
+		sd   SandboxDef
+		want bool
+	}{
+		{"plain mysql single", SandboxDef{}, false},
+		{"mariadb single", SandboxDef{Flavor: common.MariaDbFlavor}, false},
+		{"non-wsrep my.cnf options only", SandboxDef{MyCnfOptions: []string{"character-set-server=utf8mb4", "port=3306"}}, false},
+		{"wsrep_provider in MyCnfOptions", SandboxDef{MyCnfOptions: []string{"wsrep_provider=/usr/lib/libgalera_smm.so"}}, true},
+		{"wsrep_cluster_address in MyCnfOptions", SandboxDef{MyCnfOptions: []string{"wsrep_cluster_address=gcomm://127.0.0.1:4567"}}, true},
+		{"wsrep-on in MyCnfOptions", SandboxDef{MyCnfOptions: []string{"wsrep-on=ON"}}, true},
+		{"wsrep mixed with other options", SandboxDef{MyCnfOptions: []string{"character-set-server=utf8mb4", "wsrep_node_address=127.0.0.1"}}, true},
+		{"wsrep-new-cluster in StartArgs", SandboxDef{StartArgs: []string{"--wsrep-new-cluster"}}, true},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			if got := sandboxUsesWsrep(c.sd); got != c.want {
+				t.Errorf("sandboxUsesWsrep() = %v, want %v", got, c.want)
+			}
+		})
+	}
+}