Демоны и сигналы: без форк-танца, контракт SIGTERM и signal.NotifyContext как единый путь shutdown

Демон — не ты, демон — супервизор

Через несколько минут ты поймёшь, почему недописанный обработчик сигнала хуже отсутствующего — и как правильно подключить тот, который не портит состояние на деплое.

Классический ритуал юниксовой демонизации — fork, setsid для побега от управляющего терминала, ещё один fork, chdir в /, закрыть все дескрипторы, записать pidfile — решал проблему восьмидесятых: пережить logout администратора, запустившего тебя из шелла. Go-программа не должна исполнять его никогда, по двум причинам. Практическая: многопоточный рантайм не может безопасно форкаться без exec — после fork в многопоточном процессе ребёнку легальны только async-signal-safe операции, а рантайм Go — что угодно, только не это. Архитектурная: выигрывать больше нечего. systemd с Type=simple или контейнерный рантайм и есть демонизатор — он отвязывает тебя от терминала, владеет твоей группой процессов, перехватывает вывод, перезапускает при сбое и сам ведёт учёт твоего PID. Pidfile — легаси по той же причине: он существовал, чтобы init-скрипт мог найти самофоркнувшийся процесс; супервизор, который тебя запустил, и так точно знает, кто ты. Твой бинарник просто работает на переднем плане и логирует в stderr — journald или сборщик логов контейнера проставит метки, проиндексирует и отротирует.

Сигнальный контракт

Сигналы — словарь супервизора, и каждый из них — обещание, которое надо сдержать. Когда в постмортеме видишь корруцию данных или boot-loop на деплое — в девяти случаях из десяти одно из этих обещаний было нарушено:

• SIGTERM — graceful-остановка. В контракте три пункта: перестать принимать новую работу, дренировать незавершённую, выйти с кодом 0 — и всё это до того, как кончится терпение супервизора: TimeoutStopSec в systemd (по умолчанию 90 с), terminationGracePeriodSeconds в Kubernetes (по умолчанию 30 с). За дедлайном приходит SIGKILL, который ни один процесс не может перехватить, заблокировать или отложить.
• SIGINT — та же остановка, интерактивно. Ctrl-C доставляет его группе процессов переднего плана; обрабатывай его идентично SIGTERM, чтобы локальный запуск вёл себя как прод.
• SIGHUP — перезагрузка конфигурации. Исторически «терминал повешен», и его дефолтное действие до сих пор завершает процесс — поэтому необработанный SIGHUP убивает программы при закрытии терминала. Под супервизором управляющего терминала нет, и сигнал — свободная недвижимость: конвенция — перечитать конфиг и применить атомарно.
• SIGKILL и SIGSTOP — не твои. Неперехватываемы по замыслу; существование SIGKILL — причина, по которой у контракта SIGTERM есть дедлайн.

Вместе эти четыре сигнала определяют полный словарь жизненного цикла — пропусти любой, и ты либо неостановим вежливо, либо не можешь перезагрузить конфиг без аварии. И механизм, который привёл к истории из Hook: signal.Notify не наблюдает сигнал, а забирает его — рантайм отключает дефолтную диспозицию каждого зарегистрированного сигнала. Зарегистрированный, но проигнорированный SIGTERM даёт процесс, который вообще нельзя остановить вежливо.

signal.NotifyContext: shutdown — это просто отмена

Весь твой сервис уже говорит на одном языке отмены — context. signal.NotifyContext переводит сигналы на него, и «логика shutdown» схлопывается в ту же пропагацию, что ты строил в уроках про HTTP и жизненный цикл:

func main() { os.Exit(run()) }

func run() int {
	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
	defer stop()

	srv := newServer()
	go srv.ListenAndServe()          // обслуживает, пока не позовут Shutdown

	<-ctx.Done()                     // первый SIGTERM/SIGINT приземляется здесь
	stop()                           // вернуть дефолтную диспозицию: второй сигнал убивает СРАЗУ

	drainCtx, cancel := context.WithTimeout(context.Background(), 25*time.Second)
	defer cancel()
	if err := srv.Shutdown(drainCtx); err != nil {
		return 1                     // бюджет дренажа сорван — выходим грязно и громко
	}
	return 0
}

Две механики заслуживают внимательного чтения. Первая — бюджет дренажа: значение WithTimeout должно влезать в дедлайн супервизора с запасом — 25 с при 30-секундном grace-периоде Kubernetes, оставляя время на то, чтобы SIGTERM вообще долетел после снятия эндпоинта. Бюджет дренажа больше grace-периода — вежливая фикция, заканчивающаяся SIGKILL. Вторая — дисциплина двойного сигнала: вызов stop() сразу после первого сигнала снимает регистрацию, и следующий SIGTERM или ctrl-C попадает в восстановленную дефолтную диспозицию — мгновенная смерть. Это фича, а не баг: аварийный люк оператора на случай, когда дренаж завис, и каждый воспитанный демон его поставляет. Один сигнал — аккуратно. Два — немедленно.

Перезагрузка по SIGHUP: перечитать, провалидировать, подменить

Перезагрузка — отдельный канал от shutdown, и её контракт транзакционен: собери весь новый конфиг, провалидируй и только потом публикуй — через atomic.Pointer[Config], тот же паттерн подмены из урока про конфигурацию. Читатели делают Load() указателя на каждый запрос и никогда не видят полуприменённого состояния. Какой сбой это убивает: мутацию живой структуры конфига поле за полем, пока запросы её читают, — гонку данных в одежде фичи. А когда новый файл не проходит валидацию, ответ — продолжать работать на старом конфиге и громко логировать: демон, умирающий на плохой перезагрузке, превращает опечатку в аварию.

hup := make(chan os.Signal, 1)
signal.Notify(hup, syscall.SIGHUP)
go func() {
	for range hup {
		next, err := loadAndValidate(path)
		if err != nil { log.Printf("reload rejected: %v", err); continue }
		current.Store(next)          // atomic.Pointer[Config]: читатели видят старое или новое, целиком
	}
}()

systemd-юнит, честно

[Service]
Type=simple
ExecStart=/usr/local/bin/queued
Restart=on-failure
TimeoutStopSec=30
WatchdogSec=30

Type=simple говорит прямо: демонизатор — супервизор; твой процесс просто работает. Restart=on-failure перезапускает падения, но не чистые выходы — always для процессов, которые не должны останавливаться намеренно никогда. TimeoutStopSec — дедлайн SIGTERM, против которого ты дренируешь. WatchdogSec заслуживает честной рамки: с библиотекой go-systemd ты шлёшь READY=1 через sd_notify на старте и периодически WATCHDOG=1; пропустишь интервал — systemd убьёт и перезапустит. Это страховка от дедлока — она ловит заклинивший главный цикл, и не более. Классический способ заставить её лгать: пинговать из выделенной горутины, которая остаётся здоровой, пока настоящий рабочий цикл в дедлоке. Шли пинг из цикла, чья живость тебя реально волнует, — иначе ты застраховал чужой дом.