TO SQUASH OR REMOVE

Author: vr009

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

@@ -57,23 +57,36 @@ 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.instanceStateMutex.Lock()
 		if !wd.shouldStop {
@@ -87,7 +100,7 @@ func (wd *Watchdog) Start() {
 		} else {
 			wd.logger.Printf(`Watchdog(ERROR): terminated before instance start.`)
 			wd.instanceStateMutex.Unlock()
-			return
+			return nil
 		}
 		wd.instanceStateMutex.Unlock()
 
@@ -125,13 +138,21 @@ func (wd *Watchdog) Start() {
 		time.Sleep(wd.restartTimeout)
 
 		wd.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()

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()