TO SQUASH OR REMOVE

Author: vr009

cli/running/instance.go

@@ -50,6 +50,12 @@ type Instance struct {
 	waitMutex sync.Mutex
 	// done represent whether the instance was stopped.
 	done bool
+	// stateMutex used to avoid a race condition under started and shouldStop fields.
+	stateMutex sync.Mutex
+	// started indicates whether the Watchdog has started an Instance.
+	started bool
+	// shouldStop indicates whether the Watchdog should stop the Instance.
+	shouldStop bool
 }
 
 //go:embed lua/launcher.lua

cli/running/running.go

@@ -518,21 +518,17 @@ func Start(cmdCtx *cmdcontext.CmdCtx, run *InstanceCtx) error {
 	provider := providerImpl{cmdCtx: cmdCtx, instanceCtx: run}
 	wd := NewWatchdog(run.Restartable, 5*time.Second, logger, &provider)
 
-	// The signal handling loop must be started before the instance
-	// get started for avoiding a race condition between tt start
-	// and tt stop. This way we avoid a situation when we receive
-	// a signal before starting a handler for it.
-	wd.StartSignalHandling()
-
-	if err := process_utils.CreatePIDFile(run.PIDFile); err != nil {
-		return err
-	}
-
 	defer func() {
 		cleanup(run)
 	}()
 
-	wd.Start()
+	preStartAction := func() error {
+		if err := process_utils.CreatePIDFile(run.PIDFile); err != nil {
+			return err
+		}
+		return nil
+	}
+	wd.Start(preStartAction)
 	return nil
 }
 

cli/running/watchdog.go

@@ -42,12 +42,6 @@ type Watchdog struct {
 	// and updating may depend on changing external parameters
 	// (such as configuration file).
 	provider Provider
-	// instanceStateMutex used to avoid a race condition under started and shouldStop fields.
-	instanceStateMutex sync.Mutex
-	// started indicates whether the Watchdog has started an Instance.
-	started bool
-	// shouldStop indicates whether the Watchdog should stop the Instance.
-	shouldStop bool
 }
 
 // NewWatchdog creates a new instance of Watchdog.
@@ -57,48 +51,61 @@ func NewWatchdog(restartable bool, restartTimeout time.Duration, logger *ttlog.L
 		provider: provider}
 
 	wd.done = make(chan bool, 1)
-	wd.shouldStop = false
 
 	return &wd
 }
 
 // Start starts the Instance and signal handling.
-func (wd *Watchdog) Start() {
+func (wd *Watchdog) Start(preStartAction func() error) error {
+	var err error
+	// Create Instance.
+	if wd.Instance, err = wd.provider.CreateInstance(wd.logger); err != nil {
+		wd.logger.Printf(`Watchdog(ERROR): "%v".`, err)
+		return err
+	}
+	wd.logger = wd.Instance.logger
+	// The signal handling loop must be started before the instance
+	// get started for avoiding a race condition between tt start
+	// and tt stop. This way we avoid a situation when we receive
+	// a signal before starting a handler for it.
+	wd.startSignalHandling()
+
+	if err = preStartAction(); err != nil {
+		wd.logger.Printf(`Pre-start action error: %v`, err)
+		// Finish the signal handling goroutine.
+		wd.done <- true
+		return err
+	}
+
 	// The Instance must be restarted on completion if the "restartable"
 	// parameter is set to "true".
 	for {
 		var err error
-		// Create Instance.
-		if wd.Instance, err = wd.provider.CreateInstance(wd.logger); err != nil {
-			wd.logger.Printf(`Watchdog(ERROR): "%v".`, err)
-			break
-		}
-		wd.logger = wd.Instance.logger
 
-		wd.stateMutex.Lock()
-		if !wd.shouldStop {
+		wd.Instance.stateMutex.Lock()
+		if !wd.Instance.shouldStop {
 			// Start the Instance.
 			if err := wd.Instance.Start(); err != nil {
 				wd.logger.Printf(`Watchdog(ERROR): "%v".`, err)
-				wd.stateMutex.Unlock()
+				wd.Instance.stateMutex.Unlock()
 				break
 			}
-			wd.started = true
+			wd.Instance.started = true
 		} else {
 			wd.logger.Printf(`Watchdog(ERROR): terminated before instance start.`)
-			wd.stateMutex.Unlock()
-			return
+			wd.Instance.stateMutex.Unlock()
+			return nil
 		}
-		wd.stateMutex.Unlock()
+		wd.Instance.stateMutex.Unlock()
 
 		// Wait while the Instance will be terminated.
 		if err := wd.Instance.Wait(); err != nil {
 			wd.logger.Printf(`Watchdog(WARN): "%v".`, err)
 		}
 
-		wd.stateMutex.Lock()
-		wd.started = false
-		wd.stateMutex.Unlock()
+		wd.Instance.stateMutex.Lock()
+		wd.Instance.started = false
+		wd.Instance.stateMutex.Unlock()
 
 		// Set Instance process completion indication.
 		wd.done <- true
@@ -111,7 +118,7 @@ func (wd *Watchdog) Start() {
 			wd.logger.Println("Watchdog(ERROR): can't check if the instance is restartable.")
 			break
 		}
-		if wd.shouldStop || !restartable {
+		if wd.Instance.shouldStop || !restartable {
 			wd.logger.Println("Watchdog(INFO): the Instance has shutdown.")
 			break
 		}
@@ -124,14 +131,22 @@ func (wd *Watchdog) Start() {
 		}
 		time.Sleep(wd.restartTimeout)
 
-		wd.shouldStop = false
+		wd.Instance.shouldStop = false
+
+		// Create Instance.
+		if wd.Instance, err = wd.provider.CreateInstance(wd.logger); err != nil {
+			wd.logger.Printf(`Watchdog(ERROR): "%v".`, err)
+			return err
+		}
+		wd.logger = wd.Instance.logger
 		// Before the restart of an instance start a new signal handling loop.
-		wd.StartSignalHandling()
+		wd.startSignalHandling()
 	}
+	return nil
 }
 
-// StartSignalHandling starts signal handling in a separate goroutine.
-func (wd *Watchdog) StartSignalHandling() {
+// startSignalHandling starts signal handling in a separate goroutine.
+func (wd *Watchdog) startSignalHandling() {
 	sigChan := make(chan os.Signal, 1)
 	// Reset the signal mask before starting of the new loop.
 	signal.Reset()
@@ -157,23 +172,23 @@ func (wd *Watchdog) StartSignalHandling() {
 			case sig := <-sigChan:
 				switch sig {
 				case syscall.SIGINT, syscall.SIGTERM:
-					wd.stateMutex.Lock()
-					if wd.started {
+					wd.Instance.stateMutex.Lock()
+					if wd.Instance.started {
 						wd.Instance.Stop(30 * time.Second)
 					}
 					// If we receive one of the "stop" signals, the
 					// program should be terminated.
-					wd.shouldStop = true
-					wd.stateMutex.Unlock()
+					wd.Instance.shouldStop = true
+					wd.Instance.stateMutex.Unlock()
 				case syscall.SIGHUP:
 					// Rotate the log files.
 					wd.logger.Rotate()
 				default:
-					wd.stateMutex.Lock()
-					if wd.started {
+					wd.Instance.stateMutex.Lock()
+					if wd.Instance.started {
 						wd.Instance.SendSignal(sig)
 					}
-					wd.stateMutex.Unlock()
+					wd.Instance.stateMutex.Unlock()
 				}
 			case _ = <-wd.done:
 				return

cli/running/watchdog_test.go

@@ -112,8 +112,9 @@ func TestWatchdogBase(t *testing.T) {
 	t.Cleanup(func() { cleanupWatchdog(wd) })
 
 	wdDoneChan := make(chan bool, 1)
+	testPreAction := func() error { return nil }
 	go func() {
-		wd.Start()
+		wd.Start(testPreAction)
 		wdDoneChan <- true
 	}()
 	waitProcessStart()
@@ -140,8 +141,9 @@ func TestWatchdogNotRestartable(t *testing.T) {
 	t.Cleanup(func() { cleanupWatchdog(wd) })
 
 	wdDoneChan := make(chan bool, 1)
+	testPreAction := func() error { return nil }
 	go func() {
-		wd.Start()
+		wd.Start(testPreAction)
 		wdDoneChan <- true
 	}()
 	waitProcessStart()