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

@@ -44,9 +44,7 @@ type Watchdog struct {
 	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 indicates whether the Watchdog should be stopped.
 	shouldStop bool
 }
 
@@ -57,37 +55,48 @@ 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 {
-			// Start the Instance.
-			if err := wd.Instance.Start(); err != nil {
-				wd.logger.Printf(`Watchdog(ERROR): "%v".`, err)
-				wd.instanceStateMutex.Unlock()
-				break
-			}
-			wd.started = true
-		} else {
+		if wd.shouldStop {
 			wd.logger.Printf(`Watchdog(ERROR): terminated before instance start.`)
 			wd.instanceStateMutex.Unlock()
-			return
+			return nil
+		}
+		// Start the Instance.
+		if err := wd.Instance.Start(); err != nil {
+			wd.logger.Printf(`Watchdog(ERROR): "%v".`, err)
+			wd.instanceStateMutex.Unlock()
+			break
 		}
 		wd.instanceStateMutex.Unlock()
 
@@ -96,10 +105,6 @@ func (wd *Watchdog) Start() {
 			wd.logger.Printf(`Watchdog(WARN): "%v".`, err)
 		}
 
-		wd.instanceStateMutex.Lock()
-		wd.started = false
-		wd.instanceStateMutex.Unlock()
-
 		// Set Instance process completion indication.
 		wd.done <- true
 		// Wait for the signal processing goroutine to complete.
@@ -125,13 +130,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()
@@ -158,22 +171,20 @@ func (wd *Watchdog) StartSignalHandling() {
 				switch sig {
 				case syscall.SIGINT, syscall.SIGTERM:
 					wd.instanceStateMutex.Lock()
-					if wd.started {
-						wd.Instance.Stop(30 * time.Second)
-					}
 					// If we receive one of the "stop" signals, the
 					// program should be terminated.
 					wd.shouldStop = true
 					wd.instanceStateMutex.Unlock()
+					if wd.Instance.IsAlive() {
+						wd.Instance.Stop(30 * time.Second)
+					}
 				case syscall.SIGHUP:
 					// Rotate the log files.
 					wd.logger.Rotate()
 				default:
-					wd.instanceStateMutex.Lock()
-					if wd.started {
+					if wd.Instance.IsAlive() {
 						wd.Instance.SendSignal(sig)
 					}
-					wd.instanceStateMutex.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()