test: try fix test

Author: dmyger

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"
@@ -86,38 +87,61 @@ type TarantoolInstance struct {
 	// Dialer to check that connection established.
 	Dialer tarantool.Dialer
 
-	done        chan error
+	is_stopping bool
 	is_done     bool
 	result      error
-	is_stopping bool
+	wg          *sync.WaitGroup
 }
 
-// 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{
+		is_stopping: false,
+		is_done:     false,
+		wg:          &sync.WaitGroup{},
 	}
+}
 
-	select {
-	case t.result = <-t.done:
+func (t *TarantoolInstance) checkDone() {
+	if t.wg == nil {
+		panic("TarantoolInstance is not initialized")
+	}
+	t.wg.Add(1)
+	go func() {
+		defer t.wg.Done()
+		t.result = t.Cmd.Wait()
 		t.is_done = true
-		return false, t.result
-	default:
-		return true, nil
+		if !t.is_stopping {
+			log.Printf("Tarantool %q was unexpected terminated: %v", t.Opts.Listen, t.result)
+		}
+	}()
+}
+
+func (t *TarantoolInstance) Wait() error {
+	if t.wg == nil {
+		panic("TarantoolInstance is not initialized")
 	}
+	t.wg.Wait()
+	if t.is_stopping {
+		return nil
+	}
+	return t.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.is_stopping = true
+	if t.is_done {
+		return nil
+	}
+	if t.Cmd != nil && t.Cmd.Process != nil {
+		if err := t.Cmd.Process.Kill(); err != nil && !t.is_done {
+			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 {
@@ -235,46 +259,77 @@ func RestartTarantool(inst *TarantoolInstance) error {
 	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
+	inst.Cmd.Stderr = os.Stderr
 
 	inst.Cmd.Env = append(
 		os.Environ(),
@@ -306,7 +361,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 +382,16 @@ func StartTarantool(startOpts StartOpts) (TarantoolInstance, error) {
 		}
 	}
 
-	working, err_st := inst.Status()
-	if !working || err_st != nil {
+	if inst.is_done && inst.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.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 +401,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)
 	}
 }
 

test_helpers/tcs/prepare.go

@@ -39,11 +39,12 @@ func writeConfig(name string, port int) error {
 
 func makeOpts(port int) (test_helpers.StartOpts, error) {
 	opts := test_helpers.StartOpts{}
-	dir, err := os.MkdirTemp("", "tcs_dir")
+	var err error
+	opts.WorkDir, err = os.MkdirTemp("", "tcs_dir")
 	if err != nil {
 		return opts, err
 	}
-	opts.ConfigFile = filepath.Join(dir, "config.yaml")
+	opts.ConfigFile = filepath.Join(opts.WorkDir, "config.yaml")
 	err = writeConfig(opts.ConfigFile, port)
 	if err != nil {
 		return opts, fmt.Errorf("can't save file %q: %w", opts.ConfigFile, err)

test_helpers/tcs/tcs.go

@@ -4,10 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"log"
 	"net"
-	"os"
-	"path/filepath"
 	"testing"
 
 	"github.com/tarantool/go-tarantool/v2"
@@ -133,10 +130,6 @@ func (t *TCS) Stop() {
 		t.conn.Close()
 	}
 	test_helpers.StopTarantoolWithCleanup(t.inst)
-	tcs_dir := filepath.Dir(t.inst.Opts.ConfigFile)
-	if err := os.RemoveAll(tcs_dir); err != nil {
-		log.Fatalf("Failed to clean TcS directory, got %s", err)
-	}
 }
 
 // Put implements "config.storage.put" method.