retry start, check stop pending

Signed-off-by: Evan Baker <[email protected]>

Author: rbtr

platform/os_windows.go

@@ -311,48 +311,88 @@ func restartHNS(ctx context.Context) error {
 	)
 	// Start the service again
 	log.Printf("Starting HNS service")
-	if err := service.Start(); err != nil {
-		return errors.Wrap(err, "could not start service")
-	}
+	_ = retry.Do(
+		tryStartServiceFn(ctx, service),
+		retry.UntilSucceeded(),
+		retry.Context(ctx),
+	)
 	log.Printf("HNS service started")
 	return nil
 }
 
 type managedService interface {
 	Control(control svc.Cmd) (svc.Status, error)
 	Query() (svc.Status, error)
+	Start(args ...string) error
 }
 
-func tryStopServiceFn(ctx context.Context, service managedService) func() error {
+func tryStartServiceFn(ctx context.Context, service managedService) func() error {
+	shouldStart := func(state svc.State) bool {
+		return !(state == svc.Running || state == svc.StartPending)
+	}
 	return func() error {
 		status, err := service.Query()
 		if err != nil {
 			return errors.Wrap(err, "could not query service status")
 		}
-		// If the service is already stopped, no need to stop it again
-		if status.State == svc.Stopped {
-			return nil
+		if shouldStart(status.State) {
+			err = service.Start()
+			if err != nil {
+				return errors.Wrap(err, "could not start service")
+			}
 		}
-		_, err = service.Control(svc.Stop)
+		// Wait for the service to start
+		ticker := time.NewTicker(500 * time.Millisecond) //nolint:gomnd // 500ms
+		defer ticker.Stop()
+		for {
+			status, err := service.Query()
+			if err != nil {
+				return errors.Wrap(err, "could not query service status")
+			}
+			if status.State == svc.Running {
+				log.Printf("service started")
+				break
+			}
+			select {
+			case <-ctx.Done():
+				return errors.Wrap(ctx.Err(), "context cancelled")
+			case <-ticker.C:
+			}
+		}
+		return nil
+	}
+}
+
+func tryStopServiceFn(ctx context.Context, service managedService) func() error {
+	shouldStop := func(state svc.State) bool {
+		return !(state == svc.Stopped || state == svc.StopPending)
+	}
+	return func() error {
+		status, err := service.Query()
 		if err != nil {
-			return errors.Wrap(err, "could not stop service")
+			return errors.Wrap(err, "could not query service status")
+		}
+		if shouldStop(status.State) {
+			_, err = service.Control(svc.Stop)
+			if err != nil {
+				return errors.Wrap(err, "could not stop service")
+			}
 		}
 		// Wait for the service to stop
 		ticker := time.NewTicker(500 * time.Millisecond) //nolint:gomnd // 500ms
 		defer ticker.Stop()
 		for {
-			log.Printf("Waiting for HNS service to stop")
 			status, err := service.Query()
 			if err != nil {
 				return errors.Wrap(err, "could not query service status")
 			}
 			if status.State == svc.Stopped {
-				log.Printf("HNS service stopped")
+				log.Printf("service stopped")
 				break
 			}
 			select {
 			case <-ctx.Done():
-				return errors.New("context cancelled")
+				return errors.Wrap(ctx.Err(), "context cancelled")
 			case <-ticker.C:
 			}
 		}

platform/os_windows_test.go

@@ -151,6 +151,7 @@ func TestExecuteCommandTimeout(t *testing.T) {
 type mockManagedService struct {
 	queryFuncs  []func() (svc.Status, error)
 	controlFunc func(svc.Cmd) (svc.Status, error)
+	startFunc   func(args ...string) error
 }
 
 func (m *mockManagedService) Query() (svc.Status, error) {
@@ -163,6 +164,10 @@ func (m *mockManagedService) Control(cmd svc.Cmd) (svc.Status, error) {
 	return m.controlFunc(cmd)
 }
 
+func (m *mockManagedService) Start(args ...string) error {
+	return m.startFunc(args...)
+}
+
 func TestTryStopServiceFn(t *testing.T) {
 	tests := []struct {
 		name        string
@@ -254,3 +259,84 @@ func TestTryStopServiceFn(t *testing.T) {
 		})
 	}
 }
+
+func TestTryStartServiceFn(t *testing.T) {
+	tests := []struct {
+		name        string
+		queryFuncs  []func() (svc.Status, error)
+		startFunc   func(...string) error
+		expectError bool
+	}{
+		{
+			name: "Service already running",
+			queryFuncs: []func() (svc.Status, error){
+				func() (svc.Status, error) {
+					return svc.Status{State: svc.Running}, nil
+				},
+			},
+			startFunc:   nil,
+			expectError: false,
+		},
+		{
+			name: "Service already starting",
+			queryFuncs: []func() (svc.Status, error){
+				func() (svc.Status, error) {
+					return svc.Status{State: svc.StartPending}, nil
+				},
+			},
+			startFunc:   nil,
+			expectError: false,
+		},
+		{
+			name: "Service starts successfully",
+			queryFuncs: []func() (svc.Status, error){
+				func() (svc.Status, error) {
+					return svc.Status{State: svc.Stopped}, nil
+				},
+				func() (svc.Status, error) {
+					return svc.Status{State: svc.Running}, nil
+				},
+			},
+			startFunc: func(...string) error {
+				return nil
+			},
+			expectError: false,
+		},
+		{
+			name: "Service fails to start",
+			queryFuncs: []func() (svc.Status, error){
+				func() (svc.Status, error) {
+					return svc.Status{State: svc.Stopped}, nil
+				},
+			},
+			startFunc: func(...string) error {
+				return errors.New("failed to start service") //nolint:err113 // test error
+			},
+			expectError: true,
+		},
+		{
+			name: "Service query fails",
+			queryFuncs: []func() (svc.Status, error){
+				func() (svc.Status, error) {
+					return svc.Status{}, errors.New("failed to query service status") //nolint:err113 // test error
+				},
+			},
+			startFunc:   nil,
+			expectError: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			service := &mockManagedService{
+				queryFuncs: tt.queryFuncs,
+				startFunc:  tt.startFunc,
+			}
+			err := tryStartServiceFn(context.Background(), service)()
+			if tt.expectError {
+				assert.Error(t, err)
+				return
+			}
+			assert.NoError(t, err)
+		})
+	}
+}