Перехват пользовательских сигналов в Go

Перевод статьи "Handling User Defined Signals in Go"

Сигналы представляют собой ограниченный способ коммуникации между процессами. Сигналы используют для прерывания выполнения программы и срабатывания определенного обработчика. К примеру, когда вы нажимаете комбинацию клавиш CTRL+C в терминале для остановки запущенной программы, то таким образом вы посылаете сигнал SIGINT. Обычно, при получении сигнала SIGINT процесс убивается, но некоторые процессы могут перехватывать сигнал и игнорировать его или выполнять некоторую подготовительную работу перед выходом. Еще один довольно известный сигнал SIGKILL намного "брутальнее". Как только процесс получает этот сигнал, то сразу же прекращает свою работу и нет никаких способов игнорировать этот сигнал. Существует очень много различных сигналов, их описание можно найти на wikipedia.

Посылать сигналы процессу можно с помощью команды kill <signal> <PID>. Тут PID - это идентификатор процесса. К примеру, чтобы завершить определенный процесс, вы можете послать сигнал SIGKILL воспользовавшись командой kill -KILL <PID>. Для удобства можно использовать команду pkill и вместо идентификатора указывать имя процесса.

В этом посте мы будем говорить о специальных пользовательских сигналах USR1 и USR2. Оба эти сигнала предоставляются всецело в ваше распоряжение и вы сами можете определить их обработчики. Я покажу несколько популярных способов их использования. Все примеры написанны на языке Go, но основные идеи не зависят от выбранного языка и могут быть реализованны на чем угодно.

Перехватывание сигналов

В Go вы можете перехватывать сигналы с использованием функции signal.Notify(chan os.Signal, syscall.Signal). Эта функция принимает канал и сообщает вам, когда произошел перехвать сигнала. Когда программа получает сигнал, то в канал посылается значение типа os.Signal. Примерно это выглядит так:

func handle(c chan os.Signal) {
    for {
        <-c // This line will block until a signal is received
        // DO SOMETHING
    }
}

func main() {
    c := make(chan os.Signal, 1)
    signal.Notify(c, syscall.SIGUSR1)
    go handle(c)
}

Теперь мы знаем как перехватывать сигналы и определять наши собственные обработчики.

Переключатель для режима логирования.

Давайте представим, что у вас есть веб-приложение, которое, конечно же, пишет логи. Сделать лог очень полным и многословным считается не очень хорошей идеей, потому что файлы логов разрастутся моментально. Именно поэтому придумали различные уровни логирования (INFO, DEBUG, WARN, и т.д.). Вы запускаете свое приложение с указанием уровня, но если вы захотите отдебажить какую ни будь проблему, то вам нужно будет перезагрузить ваше приложение с указанием другого уровня логирования.

Для простоты представим, что у вас есть только для два уровня логирования(бесшумный и многословный). Код ниже переключает уровни логирования как только процес получает сигнал USR1.

package main

import (
    "fmt"
    "io"
    "io/ioutil"
    "os"
    "os/signal"
    "sync"
    "syscall"
    "time"
)

// Определяем, куда мы будем выводить сообщения
var writeTo io.Writer = ioutil.Discard
var mutex sync.Mutex

func toggleOutput(c chan os.Signal) {
    for {
        // На этой строчке мы заблокируемся пока не получим сигнал
        <-c

        // Как только мы получили сигнал, необходимо сменить наш writer.
        // Если раньше мы писали в stdout, то меняем на ioutil.Discard
        // и, соответствено, наоборот.
        mutex.Lock()
        if writeTo == os.Stdout {
            writeTo = ioutil.Discard
        } else {
            writeTo = os.Stdout
        }
        mutex.Unlock()
    }
}

func main() {

    fmt.Printf("Process PID : %v\n", os.Getpid())

    c := make(chan os.Signal, 1)
    // В канал `c` попадет сообщение как только получим сигнал SIGUSR1.
    signal.Notify(c, syscall.SIGUSR1)
    go toggleOutput(c)

    // Бесконечный цикл, в котором мы просто увеличиваем счетчик.
    counter := 1
    for {
        mutex.Lock()
        fmt.Fprintln(writeTo, counter)
        mutex.Unlock()
        counter++
        time.Sleep(time.Second)
    }
}

Напомню, что для отправки сигнала нужно выполнить команду:

$ ps -C signals
  PID TTY          TIME CMD
17659 pts/6    00:00:00 signals
$ kill -s USR1 17659

В этом примере бинарник с программой называется signals.

И как это выглядит в действии.

Чтение конфигурационных файлов.

Еще один удобный вариант использования сигналов, это перегрузка конфигурационных файлов без перезапуска приложения. Представим, что у вас есть приложение, которое читает конфигурацию из YAML файла и просто выводит значения конфигурации на экран. Немного модифицировав это приложение, мы можем сменить старую конфигурацию на новую просто отправив необходимый сигнал.

package main

import (
    "fmt"
    "io/ioutil"
    "os"
    "os/signal"
    "sync"
    "syscall"
    "time"

    "gopkg.in/yaml.v2"
)

// Структура для нашего конфига. Есть только одно поле, его и будем выводить.
type config struct {
    Name string
}

// Обертка над конфигом, которая защищает его через mutex
type context struct {
    config
    sync.Mutex
}

// Глобальная переменная контекста
var ctx *context

func (c *context) Config() config {
    c.Lock()
    cnf := c.config
    c.Unlock()
    return cnf
}

// Функция читает конфигурационный файл "config.yml" и возвращает
// указатель на структуру конфигурации.
func readConfig() config {
    content, err := ioutil.ReadFile("config.yml")
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }

    var tmpCnf config
    err = yaml.Unmarshal(content, &tmpCnf)

    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }

    return tmpCnf
}

// Это самая интересная часть
func swapConfig(c chan os.Signal) {
    for {
        // На этой строчке мы заблокируемся пока не получим сигнал
        <-c

        // Как только получаем сигнал, читаем конфигурационный
        // файл и переключаем старый конфиг.
        ctx.Lock()
        ctx.config = readConfig()
        ctx.Unlock()
    }
}

func main() {
    fmt.Printf("Process PID : %v\n", os.Getpid())

    ctx = &context{config: readConfig()}

    c := make(chan os.Signal, 1)

    // В канал `c` попадет сообщение как только получим сигнал SIGUSR1.
    signal.Notify(c, syscall.SIGUSR1)
    go swapConfig(c)

    for {
        fmt.Println(ctx.Config().Name)
        time.Sleep(time.Second)
    }
}

И как все это выглядит в жизни.

Заключение

В этом посте я продемонстрировал два примера использования пользовательских сигналов, но вы можете использовать их по своему усмотрению. Если у вас появятся идеи или вопросы, то милости просим в комментарии.

updatedupdated2021-03-062021-03-06