¿Es posible capturar una señal Ctrl + C y ejecutar una función de limpieza, de manera "diferida"?

Quiero capturar la señal Ctrl+C( SIGINT) enviada desde la consola e imprimir algunos totales de ejecución parcial.

¿Es esto posible en Golang?

Nota: Cuando publiqué la pregunta por primera vez, estaba confundido acerca de Ctrl+Cser en SIGTERMlugar de SIGINT.

Puede usar el paquete os / signal para manejar las señales entrantes. Ctrl+ Ces SIGINT , por lo que puede usar esto para atrapar os.Interrupt.

c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
go func(){
    for sig := range c {
        // sig is a ^C, handle it
    }
}()

La manera en que usted hace que su programa finalice e imprima información depende totalmente de usted.

Esto funciona:

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time" // or "runtime"
)

func cleanup() {
    fmt.Println("cleanup")
}

func main() {
    c := make(chan os.Signal)
    signal.Notify(c, os.Interrupt, syscall.SIGTERM)
    go func() {
        <-c
        cleanup()
        os.Exit(1)
    }()

    for {
        fmt.Println("sleeping...")
        time.Sleep(10 * time.Second) // or runtime.Gosched() or similar per @misterbee
    }
}

Para agregar un poco a las otras respuestas, si realmente desea atrapar SIGTERM (la señal predeterminada enviada por el comando kill), puede usar syscall.SIGTERMen lugar de os.Interrupt. Tenga en cuenta que la interfaz syscall es específica del sistema y podría no funcionar en todas partes (por ejemplo, en Windows). Pero funciona muy bien para atrapar ambos:

c := make(chan os.Signal, 2)
signal.Notify(c, os.Interrupt, syscall.SIGTERM)
....

Había (al momento de publicar) uno o dos pequeños errores tipográficos en la respuesta aceptada arriba, así que aquí está la versión limpia. En este ejemplo, detengo el generador de perfiles de CPU cuando recibo Ctrl+ C.

// capture ctrl+c and stop CPU profiler                            
c := make(chan os.Signal, 1)                                       
signal.Notify(c, os.Interrupt)                                     
go func() {                                                        
  for sig := range c {                                             
    log.Printf("captured %v, stopping profiler and exiting..", sig)
    pprof.StopCPUProfile()                                         
    os.Exit(1)                                                     
  }                                                                
}()    

Todo lo anterior parece funcionar cuando se empalma, pero la página de señales de gobyexample tiene un ejemplo realmente limpio y completo de captura de señal. Vale la pena agregar a esta lista.

La muerte es una biblioteca simple que utiliza canales y un grupo de espera para esperar las señales de apagado. Una vez que se haya recibido la señal, llamará a un método de cierre en todas sus estructuras que desea limpiar.

Puede tener una rutina diferente que detecte las señales syscall.SIGINT y syscall.SIGTERM y las transmita a un canal utilizando la señal . Puede enviar un gancho a esa rutina utilizando un canal y guardarlo en un segmento de función. Cuando se detecta la señal de apagado en el canal, puede ejecutar esas funciones en el segmento. Esto se puede usar para limpiar los recursos, esperar a que finalicen las rutinas de ejecución, conservar datos o imprimir totales de ejecución parciales.

Escribí una utilidad pequeña y simple para agregar y ejecutar ganchos en el apagado. Espero que pueda ser de ayuda.

https://github.com/ankit-arora/go-utils/blob/master/go-shutdown-hook/shutdown-hook.go

Puede hacer esto de manera 'diferida'.

ejemplo para apagar un servidor con gracia:

srv := &http.Server{}

go_shutdown_hook.ADD(func() {
    log.Println("shutting down server")
    srv.Shutdown(nil)
    log.Println("shutting down server-done")
})

l, err := net.Listen("tcp", ":3090")

log.Println(srv.Serve(l))

go_shutdown_hook.Wait()

Esta es otra versión que funciona en caso de que tenga que limpiar algunas tareas. El código dejará el proceso de limpieza en su método.

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"

)



func main() {

    _,done1:=doSomething1()
    _,done2:=doSomething2()

    //do main thread


    println("wait for finish")
    <-done1
    <-done2
    fmt.Print("clean up done, can exit safely")

}

func doSomething1() (error, chan bool) {
    //do something
    done:=make(chan bool)
    c := make(chan os.Signal, 2)
    signal.Notify(c, os.Interrupt, syscall.SIGTERM)
    go func() {
        <-c
        //cleanup of something1
        done<-true
    }()
    return nil,done
}


func doSomething2() (error, chan bool) {
    //do something
    done:=make(chan bool)
    c := make(chan os.Signal, 2)
    signal.Notify(c, os.Interrupt, syscall.SIGTERM)
    go func() {
        <-c
        //cleanup of something2
        done<-true
    }()
    return nil,done
}

en caso de que necesite limpiar la función principal, también necesita capturar la señal en el hilo principal usando go func ().

Solo para el registro si alguien necesita una forma de manejar las señales en Windows. Tenía un requisito para manejar desde el programa A llamando al programa B a través de os / exec pero el programa B nunca pudo terminar con gracia porque enviaba señales a través de ex. cmd.Process.Signal (syscall.SIGTERM) u otras señales no son compatibles con Windows. La forma en que manejé es creando un archivo temporal como una señal ex. .signal.term a través del programa A y el programa B deben verificar si ese archivo existe en la base de intervalos, si existe el archivo, saldrá del programa y se encargará de una limpieza si es necesario, estoy seguro de que hay otras formas, pero esto hizo el trabajo.