Segnali di cattura Golang

Question

Voglio implementare un "wrapper di processo" in Go. Fondamentalmente quello che farà, è avviare un processo (diciamo un server nodo) e monitorarlo (prendere segnali come SIGKILL, SIGTERM ...)

Penso che il modo per fare sia lanciare il server nodo in un go di routine utilizzando syscall.Exec:

func launchCmd(path string, args []string) { 
    err := syscall.Exec(path, args, os.Environ()) 
    if err != nil { 
    panic(err) 
    } 
} 

Poi mi piacerebbe cogliere ogni possibile segnali generati dal comando eseguito da syscall. Sono abbastanza nuovo per andare, ogni aiuto sarebbe apprezzato.

Answer 1

ci sono tre modi di esecuzione di un programma in Go:

1. syscall pacchetto con syscall.Exec, syscall.ForkExec, syscall.StartProcess
2. os pacchetto con os.StartProcess
3. os/exec pacchetto con exec.Command

syscall.StartProcess è di basso livello. Restituisce un uintptr come handle.

os.StartProcess fornisce una bella struttura os.Process che è possibile chiamare Signal su. os/exec ti dà io.ReaderWriter da utilizzare su una pipe. Entrambi usano internamente syscall.

I segnali di lettura inviati da un processo diverso dal proprio sembra un po 'complicato. Se fosse possibile, syscall sarebbe in grado di farlo. Non vedo nulla di ovvio nei pacchetti di livello superiore.

per ricevere un segnale è possibile utilizzare signal.Notify come questo:

sigc := make(chan os.Signal, 1) 
signal.Notify(sigc, 
    syscall.SIGHUP, 
    syscall.SIGINT, 
    syscall.SIGTERM, 
    syscall.SIGQUIT) 
go func() { 
    s := <-sigc 
    // ... do something ... 
}() 

Hai solo bisogno di cambiare i segnali che ti interessa ascoltare. Se non si specifica un segnale, catturerà tutti i segnali che possono essere catturati.

È possibile utilizzare syscall.Kill o Process.Signal per mappare il segnale. È possibile ottenere il pid da Process.Pid o come risultato da syscall.StartProcess.

Answer 2

È possibile utilizzare signal.Notify:

import (
"os" 
"os/signal" 
"syscall" 
) 

func main() { 
    signalChannel := make(chan os.Signal, 2) 
    signal.Notify(signalChannel, os.Interrupt, syscall.SIGTERM) 
    go func() { 
     sig := <-signalChannel 
     switch sig { 
     case os.Interrupt: 
      //handle SIGINT 
     case syscall.SIGTERM: 
      //handle SIGTERM 
     } 
    }() 
    // ... 
}