There are no results.

Handling of Unix signals.

This module allows processes to wait for Unix signals to be received, overriding their default behaviour in the process. To do so, create an instance of the Signal enum and call Signal.wait on it:

import std.signal (Signal)

Signal.User1.wait

Signals are handled asynchronously, meaning there may be a small delay between receiving the signal and Signal.wait returning. The order in which signals are received is unspecified. The underlying platform may also coalesce multiple instances of the same signal being received into a single receive, such that sending e.g. SIGHUP 3 times in a short period results in it only being received once.

Default signal handlers

If no process is waiting for a specific signal and the signal is received, it's default behaviour according to the underlying platform is invoked. For example, the default signal handler for SIGUSR1 terminates the current process.

Supported signals

To increase portability and to prevent users from handling problematic signals (SIGSEGV or SIGFPE for example), this module only supports a limited number of signals.

Handling of SIGPIPE isn't supported as this is almost always a terrible idea, and the runtime disables/masks this signal as to not interfere with (amongst other things) non-blocking sockets.

Waiting for multiple signals

If you need to wait for multiple signals at once, you can do so using a Channel and a process for each signal. For example:

import std.signal (Signal)

class async Waiter {
  let @channel: Channel[Signal]

  fn async wait(signal: uni Signal) {
    signal.wait
    @channel.send(signal)
  }
}

class async Main {
  fn async main {
    let chan = Channel.new(size: 2)

    Waiter(chan).wait(recover Signal.User1)
    Waiter(chan).wait(recover Signal.User2)
    chan.receive
  }
}

In this example the chan.receive line returns either uni Signal.User1 or uni Signal.User2, depending on which signal is received first.

Classes