Using Signals to Handle Unix Commands in Golang

Learn to use in-built Go features to handle Unix commands

Photo by Harshal Desai on Unsplash

Accepting and processing signals from the operating system is important for various use cases in applications.

While many server-side languages have complicated or tedious approaches to processing signals from the OS, with Golang applications it’s extremely intuitive. Golang’s in-built OS package provides an easy way to integrate and react to Unix signals from your Go application. Let’s see how.

The Premise

Let’s say we want to build a Golang application that when requested to shutdown prints a message saying, “Thank you for using Golang.” Let’s set up the main function that basically keeps doing some work until an exit command is provided to the application.

func main() {
   for {
      fmt.Println("Doing Work")
      time.Sleep(1 * time.Second)
   }
}

When you run this application and kill it by providing a kill signal from your OS (Ctrl + C or Ctrl + Z, in most cases), you may see an output similar to this one:

Doing Work
Doing Work
Doing Work
Process finished with exit code 2

Now, we would like to interpret this kill signal within the Golang application and process it to print out the required exit message.

Receiving Signals

We will create a channel to receive the command from the OS. The OS package provides the Signal interface to handle signals and has OS-specific implementations.

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

To notify killSignal, we use the Notify function provided by the signal package. The first parameter takes a channel of a os.Signal, while the next parameters accept a list of OS signals we want to notify our channel with.

signal.Notify(killSignal, os.Interrupt)

Alternatively, we can notify our signal with specific commands using the syscall package.

signal.Notify(killSignal, syscall.SIGINT, syscall.SIGTERM)

In order to process the signal, we’ll make our main function block wait for the interrupt signal…