Add error/panic handling for the Startup of components

Author: TheOneWithTheWrench

manager.go

@@ -30,6 +30,8 @@ type Manager struct {
 	setupTimeout time.Duration
 	closeTimeout time.Duration
 	lifetime     TerminationSignal
+
+	exitSignal chan syscall.Signal
 }
 
 func NewManager(options ...managerOption) *Manager {
@@ -43,6 +45,7 @@ func NewManager(options ...managerOption) *Manager {
 		setupTimeout: ops.setupTimeout,
 		closeTimeout: ops.closeTimeout,
 		lifetime:     ops.lifetime,
+		exitSignal:   make(chan syscall.Signal, 1),
 	}
 }
 
@@ -63,7 +66,7 @@ func (m *Manager) Run() syscall.Signal {
 
 	m.startComponents()
 
-	signal := m.lifetime() // Wait for the exit signal
+	signal := m.waitForSignal() // Wait for the exit signal
 
 	err = m.closeComponents()
 	if errors.Is(err, errTimeout) {
@@ -95,27 +98,38 @@ func (m *Manager) setupComponents() error {
 	return nil
 }
 
-// TODO: startComponents could definitely use some more love
-// It would be great for a way for start methods to signal the manager that a start errored, this way we can make sure we close back down gracefully..
-// Maybe something can be done with error groups?
-//
-// TODO: We should probably also think in some panic handling... Maybe that goes for Setup and Close aswell
 func (m *Manager) startComponents() {
 	for _, s := range m.components {
 		startable, ok := s.Component.(startable)
 		if ok {
 			m.logger.Info(fmt.Sprintf("[UnixCycle] Starting component %q", s.name), slog.String("component_name", s.name))
 			go func() {
+				defer func() {
+					if r := recover(); r != nil {
+						m.logger.Error(fmt.Sprintf("[UnixCycle] Panic during start for component %q: %v", s.name, r), slog.String("component_name", s.name))
+						m.exitSignal <- syscall.SIGABRT
+					}
+				}()
 				err := startable.Start() // Blocking for go routine
 				if err != nil {
-					//TODO: We need to signal the manager somehow that a start failed...
 					m.logger.Error(fmt.Sprintf("[UnixCycle] Failure during start for component %q: %v", s.name, err), slog.String("component_name", s.name))
+					m.exitSignal <- syscall.SIGABRT
 				}
 			}()
 		}
 	}
 }
 
+func (m *Manager) waitForSignal() syscall.Signal {
+	go func() {
+		m.exitSignal <- m.lifetime()
+	}()
+
+	signal := <-m.exitSignal
+	m.logger.Info(fmt.Sprintf("[UnixCycle] Received signal: %v", signal), slog.String("signal", signal.String()))
+	return signal
+}
+
 func (m *Manager) closeComponents() error {
 	for _, s := range slices.Backward(m.components) {
 		closable, ok := s.Component.(closable)

manager_test.go

@@ -121,6 +121,56 @@ func TestManager(t *testing.T) {
 		assert.Equal(t, uint32(0), calledCount.Load())
 		assert.Equal(t, syscall.SIGALRM, got)
 	})
+
+	t.Run("should close back down when a start function errors", func(t *testing.T) {
+		var (
+			m, _         = newManager()
+			startCalled  = false
+			closedCalled = false
+			closeable    = func() error {
+				closedCalled = true
+				return nil
+			}
+			startable = func() error {
+				startCalled = true
+				return assert.AnError
+			}
+			sut = m.
+				Add("startable func", unixcycle.Starter(startable)).
+				Add("closable func", unixcycle.Closer(closeable))
+		)
+
+		got := sut.Run()
+
+		assert.Equal(t, startCalled, true, "startable func should have been called")
+		assert.Equal(t, closedCalled, true, "closable func should have been called")
+		assert.Equal(t, syscall.SIGABRT, got)
+	})
+
+	t.Run("should close back down when a start function panics", func(t *testing.T) {
+		var (
+			m, _         = newManager()
+			startCalled  = false
+			closedCalled = false
+			closeable    = func() error {
+				closedCalled = true
+				return nil
+			}
+			startable = func() error {
+				startCalled = true
+				panic("panic")
+			}
+			sut = m.
+				Add("startable func", unixcycle.Starter(startable)).
+				Add("closable func", unixcycle.Closer(closeable))
+		)
+
+		got := sut.Run()
+
+		assert.Equal(t, startCalled, true, "startable func should have been called")
+		assert.Equal(t, closedCalled, true, "closable func should have been called")
+		assert.Equal(t, syscall.SIGABRT, got)
+	})
 }
 
 type testComponent struct {