diff --git a/signals_test.go b/signals_test.go index ea0904bc..deeb49e7 100644 --- a/signals_test.go +++ b/signals_test.go @@ -55,3 +55,69 @@ func TestHandleSignalsReturnsAfterContextCancelDuringPendingSend(t *testing.T) { t.Fatal("handleSignals did not return after context cancel: signal goroutine is deadlocked") } } + +// TestHandleSignalsCatchesSecondSignalDuringShutdown is a regression test for +// https://github.com/charmbracelet/bubbletea/issues/1849: after a quit +// message is forwarded, the signal subscription must stay alive until the +// program finishes, so a second SIGINT during shutdown is caught instead of +// taking the runtime's default path and killing the process. +func TestHandleSignalsCatchesSecondSignalDuringShutdown(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + // Register our own handler first so a SIGINT can never take down the + // test process, whether or not handleSignals is catching it. + ours := make(chan os.Signal, 2) + signal.Notify(ours, syscall.SIGINT) + defer signal.Stop(ours) + + finished := make(chan struct{}) + defer close(finished) + + p := &Program{ + ctx: ctx, + msgs: make(chan Msg), + finished: finished, + } + + done := p.handleSignals() + time.Sleep(100 * time.Millisecond) // let the handler register its signal.Notify + + // While the program runs, every signal is forwarded as an interrupt + // message, so a program that doesn't quit on the first one (for example + // because a filter dropped it) still gets the next one. + for i := range 2 { + if err := syscall.Kill(os.Getpid(), syscall.SIGINT); err != nil { + t.Fatalf("failed to send SIGINT: %v", err) + } + <-ours + + select { + case msg := <-p.msgs: + if _, ok := msg.(InterruptMsg); !ok { + t.Fatalf("expected InterruptMsg, got %T", msg) + } + case <-time.After(5 * time.Second): + t.Fatalf("SIGINT %d was not forwarded", i+1) + } + } + + // Context cancellation (the start of shutdown) ends the handler. + cancel() + select { + case <-done: + case <-time.After(5 * time.Second): + t.Fatal("handleSignals did not finish after context cancel") + } + + // Release our own watcher so that whether SIGINT is still caught depends + // solely on the program's subscription. A second SIGINT during the + // shutdown window must still be caught (and dropped); if the program had + // already released its subscription it would take the runtime's default + // path and terminate this test process — so surviving is the assertion. + signal.Stop(ours) + if err := syscall.Kill(os.Getpid(), syscall.SIGINT); err != nil { + t.Fatalf("failed to send second SIGINT: %v", err) + } + time.Sleep(200 * time.Millisecond) +} diff --git a/tea.go b/tea.go index 3c780072..3b147685 100644 --- a/tea.go +++ b/tea.go @@ -672,6 +672,11 @@ func NewProgram(model Model, opts ...ProgramOption) *Program { func (p *Program) handleSignals() chan struct{} { ch := make(chan struct{}) + // Run sets finished before it starts the handlers. Read it here, not in + // the goroutine below, which may still be running when Run is called + // again and replaces it. + finished := p.finished + // Listen for SIGINT and SIGTERM. // // In most cases ^C will not send an interrupt because the terminal will be @@ -683,27 +688,34 @@ func (p *Program) handleSignals() chan struct{} { go func() { sig := make(chan os.Signal, 1) signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM) - defer func() { - signal.Stop(sig) - close(ch) - }() + defer signal.Stop(sig) for { select { case <-p.ctx.Done(): + // The program is shutting down: report the handler done so + // shutdown can proceed, but keep the signal subscription + // alive until Run returns. A second SIGINT/SIGTERM arriving + // while the terminal is being restored is then caught and + // dropped instead of taking the runtime's default path, + // which kills the process before the terminal is restored. + close(ch) + if finished != nil { + <-finished + } return case s := <-sig: - if atomic.LoadUint32(&p.ignoreSignals) == 0 { - var msg Msg = QuitMsg{} - if s == syscall.SIGINT { - msg = InterruptMsg{} - } - select { - case p.msgs <- msg: - case <-p.ctx.Done(): - } - return + if atomic.LoadUint32(&p.ignoreSignals) != 0 { + continue + } + var msg Msg = QuitMsg{} + if s == syscall.SIGINT { + msg = InterruptMsg{} + } + select { + case p.msgs <- msg: + case <-p.ctx.Done(): } } }