test: try fix test

Author: dmyger

.github/workflows/reusable_testing.yml

@@ -11,7 +11,7 @@ on:
 
 jobs:
   run_tests:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
       - name: Clone the go-tarantool connector
         uses: actions/checkout@v4

.github/workflows/testing.yml

@@ -23,7 +23,7 @@ jobs:
 
     # We could replace it with ubuntu-latest after fixing the bug:
     # https://github.com/tarantool/setup-tarantool/issues/37
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
 
     strategy:
       fail-fast: false
@@ -100,9 +100,10 @@ jobs:
         run: make deps
 
       - name: Run regression tests
-        run: |
-          make test
-          make testrace
+        run: make test
+
+      - name: Run race tests
+        run: make testrace
 
       - name: Run fuzzing tests
         if: ${{ matrix.fuzzing }}
@@ -116,6 +117,7 @@ jobs:
           make coveralls
 
       - name: Check workability of benchmark tests
+        if: matrix.golang == 'stable'
         run: make bench-deps bench DURATION=1x COUNT=1
 
   testing_mac_os:
@@ -270,6 +272,10 @@ jobs:
         run: |
           cd "${SRCDIR}"
           make test
+
+      - name: Run race tests
+        run: |
+          cd "${SRCDIR}"
           make testrace
 
       - name: Run fuzzing tests
@@ -279,6 +285,7 @@ jobs:
           make fuzzing TAGS="go_tarantool_decimal_fuzzing"
 
       - name: Check workability of benchmark tests
+        if: matrix.golang == 'stable'
         run: |
           cd "${SRCDIR}"
           make bench-deps bench DURATION=1x COUNT=1

shutdown_test.go

@@ -108,7 +108,7 @@ func testGracefulShutdown(t *testing.T, conn *Connection, inst *test_helpers.Tar
 	// Wait until server go down.
 	// Server will go down only when it process all requests from our connection
 	// (or on timeout).
-	_, err = inst.Cmd.Process.Wait()
+	err = inst.Wait()
 	require.Nil(t, err)
 	shutdownFinish := time.Now()
 	shutdownTime := shutdownFinish.Sub(shutdownStart)
@@ -256,7 +256,7 @@ func TestNoGracefulShutdown(t *testing.T) {
 	require.NotNilf(t, err, "sleep request error")
 
 	// Wait until server go down.
-	_, err = inst.Cmd.Process.Wait()
+	err = inst.Wait()
 	require.Nil(t, err)
 	shutdownFinish := time.Now()
 	shutdownTime := shutdownFinish.Sub(shutdownStart)
@@ -327,7 +327,7 @@ func TestGracefulShutdownRespectsClose(t *testing.T) {
 	require.NotNilf(t, err, "sleep request error")
 
 	// Wait until server go down.
-	_, err = inst.Cmd.Process.Wait()
+	err = inst.Wait()
 	require.Nil(t, err)
 	shutdownFinish := time.Now()
 	shutdownTime := shutdownFinish.Sub(shutdownStart)
@@ -401,7 +401,7 @@ func TestGracefulShutdownNotRacesWithRequestReconnect(t *testing.T) {
 
 	// Wait until server go down.
 	// Server is expected to go down on timeout.
-	_, err = inst.Cmd.Process.Wait()
+	err = inst.Wait()
 	require.Nil(t, err)
 
 	// Help test helpers to properly clean up.
@@ -497,7 +497,7 @@ func TestGracefulShutdownCloseConcurrent(t *testing.T) {
 	srvStop.Wait()
 	require.Nil(t, sret, "No errors on server SIGTERM")
 
-	_, err = inst.Cmd.Process.Wait()
+	err = inst.Wait()
 	require.Nil(t, err)
 
 	// Help test helpers to properly clean up.
@@ -590,7 +590,7 @@ func TestGracefulShutdownConcurrent(t *testing.T) {
 	caseWg.Wait()
 	require.Nil(t, ret, "No errors on concurrent wait")
 
-	_, err = inst.Cmd.Process.Wait()
+	err = inst.Wait()
 	require.Nil(t, err)
 
 	// Help test helpers to properly clean up.

test_helpers/main.go

@@ -21,6 +21,7 @@ import (
 	"path/filepath"
 	"regexp"
 	"strconv"
+	"sync"
 	"time"
 
 	"github.com/tarantool/go-tarantool/v2"
@@ -75,6 +76,17 @@ type StartOpts struct {
 	Dialer tarantool.Dialer
 }
 
+type statusInstance struct {
+	result     error
+	isStopping bool
+	isDone     bool
+	//! wg         sync.WaitGroup
+	// waitMutex is used to prevent several invokes of the "Wait"
+	// for the same process.
+	// https://github.com/golang/go/issues/28461
+	waitMutex sync.Mutex
+}
+
 // TarantoolInstance is a data for instance graceful shutdown and cleanup.
 type TarantoolInstance struct {
 	// Cmd is a Tarantool command. Used to kill Tarantool process.
@@ -86,38 +98,60 @@ type TarantoolInstance struct {
 	// Dialer to check that connection established.
 	Dialer tarantool.Dialer
 
-	done        chan error
-	is_done     bool
-	result      error
-	is_stopping bool
+	st *statusInstance
 }
 
-// Status checks if Tarantool instance is still running.
-// Return true if it is running, false if it is not.
-// If instance was exit and error is nil - process completed success with zero status code.
-func (t *TarantoolInstance) Status() (bool, error) {
-	if t.is_done {
-		return false, t.result
-	}
+func newTarantoolInstance() TarantoolInstance {
+	return TarantoolInstance{st: &statusInstance{}}
+}
 
-	select {
-	case t.result = <-t.done:
-		t.is_done = true
-		return false, t.result
-	default:
-		return true, nil
+func (t *TarantoolInstance) checkDone() {
+	if t.st == nil {
+		panic("TarantoolInstance is not initialized")
+	}
+	// t.st.wg.Add(1)
+	go func() {
+		// defer t.st.wg.Done()
+		t.st.waitMutex.Lock()
+		defer t.st.waitMutex.Unlock()
+		if t.st.isDone {
+			return
+		}
+		t.st.result = t.Cmd.Wait()
+		t.st.isDone = true
+		if !t.st.isStopping {
+			log.Printf("Tarantool %q was unexpected terminated: %v", t.Opts.Listen, t.st.result)
+		}
+	}()
+}
+
+func (t *TarantoolInstance) Wait() error {
+	if t.st == nil {
+		panic("TarantoolInstance is not initialized")
 	}
+	//! t.st.wg.Wait()
+	t.st.waitMutex.Lock()
+	defer t.st.waitMutex.Unlock()
+	return t.st.result
 }
 
-func (t *TarantoolInstance) checkDone() {
-	t.is_done = false
-	t.is_stopping = false
-	t.done = make(chan error, 1)
-	t.done <- t.Cmd.Wait()
-	if !t.is_stopping {
-		_, err := t.Status()
-		log.Printf("Tarantool was unexpected terminated: %s", err)
+func (t *TarantoolInstance) Stop() error {
+	log.Printf("Stopping Tarantool instance %q", t.Opts.Listen)
+	t.st.isStopping = true
+	if t.st.isDone {
+		log.Printf("Already stopped instance %q with result: %v", t.Opts.Listen, t.st.result)
+		return nil
+	}
+	if t.Cmd != nil && t.Cmd.Process != nil {
+		log.Printf("Killing Tarantool %q (pid %d)", t.Opts.Listen, t.Cmd.Process.Pid)
+		if err := t.Cmd.Process.Kill(); err != nil && !t.st.isDone {
+			return fmt.Errorf("failed to kill tarantool %q (pid %d), got %s",
+				t.Opts.Listen, t.Cmd.Process.Pid, err)
+		}
+		t.Wait()
+		t.Cmd.Process = nil
 	}
+	return nil
 }
 
 func isReady(dialer tarantool.Dialer, opts *tarantool.Opts) error {
@@ -232,49 +266,81 @@ func IsTarantoolEE() (bool, error) {
 func RestartTarantool(inst *TarantoolInstance) error {
 	startedInst, err := StartTarantool(inst.Opts)
 	inst.Cmd.Process = startedInst.Cmd.Process
+	inst.st = startedInst.st
 	return err
 }
 
+func removeByMask(dir string, masks ...string) error {
+	for _, mask := range masks {
+		files, err := filepath.Glob(filepath.Join(dir, mask))
+		if err != nil {
+			return err
+		}
+		for _, f := range files {
+			if err = os.Remove(f); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func prepareDir(workDir string) (string, error) {
+	if workDir == "" {
+		dir, err := os.MkdirTemp("", "work_dir")
+		if err != nil {
+			return "", err
+		}
+		return dir, nil
+	}
+	// Create work_dir.
+	err := os.MkdirAll(workDir, 0755)
+	if err != nil {
+		return "", err
+	}
+
+	// Clean up existing work_dir.
+	// TODO: Ensure that nested files will be removed.
+	err = removeByMask(workDir, "*.snap", "*.xlog")
+	if err != nil {
+		return "", err
+	}
+	return workDir, nil
+}
+
 // StartTarantool starts a tarantool instance for tests
 // with specifies parameters (refer to StartOpts).
 // Process must be stopped with StopTarantool.
 func StartTarantool(startOpts StartOpts) (TarantoolInstance, error) {
 	// Prepare tarantool command.
-	var inst TarantoolInstance
-	var dir string
+	inst := newTarantoolInstance()
 	var err error
 
 	inst.Dialer = startOpts.Dialer
-
-	if startOpts.WorkDir == "" {
-		dir, err = os.MkdirTemp("", "work_dir")
-		if err != nil {
-			return inst, err
-		}
-		startOpts.WorkDir = dir
-	} else {
-		// Clean up existing work_dir.
-		err = os.RemoveAll(startOpts.WorkDir)
-		if err != nil {
-			return inst, err
-		}
-
-		// Create work_dir.
-		err = os.Mkdir(startOpts.WorkDir, 0755)
-		if err != nil {
-			return inst, err
-		}
+	startOpts.WorkDir, err = prepareDir(startOpts.WorkDir)
+	if err != nil {
+		return inst, fmt.Errorf("failed prepare working dir %q: %w", startOpts.WorkDir, err)
 	}
-	args := []string{}
 
+	args := []string{}
 	if startOpts.InitScript != "" {
+		if !filepath.IsAbs(startOpts.InitScript) {
+			cwd, err := os.Getwd()
+			if err != nil {
+				return inst, fmt.Errorf("failed to get current working directory: %w", err)
+			}
+			startOpts.InitScript = filepath.Join(cwd, startOpts.InitScript)
+		}
 		args = append(args, startOpts.InitScript)
 	}
 	if startOpts.ConfigFile != "" && startOpts.InstanceName != "" {
 		args = append(args, "--config", startOpts.ConfigFile)
 		args = append(args, "--name", startOpts.InstanceName)
 	}
 	inst.Cmd = exec.Command(getTarantoolExec(), args...)
+	inst.Cmd.Dir = startOpts.WorkDir
+	inst.Cmd.Stdout = os.Stderr //! DEBUG: remove
+	inst.Cmd.Stderr = os.Stderr //! DEBUG: remove
 
 	inst.Cmd.Env = append(
 		os.Environ(),
@@ -306,7 +372,7 @@ func StartTarantool(startOpts StartOpts) (TarantoolInstance, error) {
 	// see https://github.com/tarantool/go-tarantool/issues/136
 	time.Sleep(startOpts.WaitStart)
 
-	go inst.checkDone()
+	inst.checkDone()
 
 	opts := tarantool.Opts{
 		Timeout:    500 * time.Millisecond,
@@ -327,15 +393,16 @@ func StartTarantool(startOpts StartOpts) (TarantoolInstance, error) {
 		}
 	}
 
-	working, err_st := inst.Status()
-	if !working || err_st != nil {
+	if inst.st.isDone && inst.st.result != nil {
 		StopTarantool(inst)
-		return TarantoolInstance{}, fmt.Errorf("unexpected terminated Tarantool: %w", err_st)
+		return TarantoolInstance{}, fmt.Errorf("unexpected terminated Tarantool %q: %w",
+			inst.Opts.Listen, inst.st.result)
 	}
 
 	if err != nil {
 		StopTarantool(inst)
-		return TarantoolInstance{}, fmt.Errorf("failed to connect Tarantool: %w", err)
+		return TarantoolInstance{}, fmt.Errorf("failed to connect Tarantool %q: %w",
+			inst.Opts.Listen, err)
 	}
 
 	return inst, nil
@@ -345,25 +412,9 @@ func StartTarantool(startOpts StartOpts) (TarantoolInstance, error) {
 // with StartTarantool. Waits until any resources
 // associated with the process is released. If something went wrong, fails.
 func StopTarantool(inst TarantoolInstance) {
-	log.Printf("Stopping Tarantool instance")
-	inst.is_stopping = true
-	if inst.Cmd != nil && inst.Cmd.Process != nil {
-		if err := inst.Cmd.Process.Kill(); err != nil {
-			is_running, _ := inst.Status()
-			if is_running {
-				log.Fatalf("Failed to kill tarantool (pid %d), got %s", inst.Cmd.Process.Pid, err)
-			}
-		}
-
-		// Wait releases any resources associated with the Process.
-		if _, err := inst.Cmd.Process.Wait(); err != nil {
-			is_running, _ := inst.Status()
-			if is_running {
-				log.Fatalf("Failed to wait for Tarantool process to exit, got %s", err)
-			}
-		}
-
-		inst.Cmd.Process = nil
+	err := inst.Stop()
+	if err != nil {
+		log.Fatal(err)
 	}
 }