clawbot
c96b77dd67
check / check (push) Failing after 1s
SIGINT, SIGTERM and SIGHUP are no longer caught for the whole run, so they end any command at once, the mnemonic prompt included. One package, internal/cli/signals, catches them only where cleanup is needed, and only those not ignored at start, so nohup still works: ssh to and ssh install while their child runs, and age encrypt -o and age decrypt -o while they write. A signal received by the time the input ends leaves no new file and exits 1; otherwise the whole file is put in place, never an unfinished one. Judgement call: the guarantee is stated for a signal keyfunc has received, as Go cannot promise more; the main goroutine stays on the main thread so a Ctrl-C on a pipeline is seen first on Linux. Unverified on macOS. Model: opus-5-5 (implementation); fable-5-1 (design)
54 lines
1.5 KiB
Go
54 lines
1.5 KiB
Go
// Package signals catches the signals that end the tool, for the
|
|
// commands that clean up before they end.
|
|
package signals
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"os/signal"
|
|
"syscall"
|
|
)
|
|
|
|
// Context is signal.NotifyContext for SIGINT, SIGTERM and SIGHUP: the
|
|
// context it returns is cancelled when one of them arrives, and stop
|
|
// stops catching them. It leaves out any of the three the tool was
|
|
// started with set to be ignored, as nohup does with SIGHUP, because
|
|
// catching a signal turns an ignored one back on and would end a run
|
|
// that was meant to survive it.
|
|
func Context(parent context.Context) (context.Context, context.CancelFunc) {
|
|
endings := caught()
|
|
|
|
// Given no signals at all, NotifyContext would catch every one.
|
|
if len(endings) == 0 {
|
|
return context.WithCancel(parent)
|
|
}
|
|
|
|
return signal.NotifyContext(parent, endings...)
|
|
}
|
|
|
|
// Notify is signal.Notify for the signals Context catches: each one
|
|
// that arrives is sent to c, until signal.Stop(c).
|
|
func Notify(c chan<- os.Signal) {
|
|
endings := caught()
|
|
|
|
// Given no signals at all, Notify would catch every one.
|
|
if len(endings) > 0 {
|
|
signal.Notify(c, endings...)
|
|
}
|
|
}
|
|
|
|
// caught returns those of SIGINT, SIGTERM and SIGHUP that the tool was
|
|
// not started with set to be ignored.
|
|
func caught() []os.Signal {
|
|
endings := []os.Signal{syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP}
|
|
kept := make([]os.Signal, 0, len(endings))
|
|
|
|
for _, ending := range endings {
|
|
if !signal.Ignored(ending) {
|
|
kept = append(kept, ending)
|
|
}
|
|
}
|
|
|
|
return kept
|
|
}
|