package async_unix

You can search for identifiers within the package.

in-package search v0.2.0

Monadic concurrency library

Install

Dune Dependency

github.com Readme Changelog MIT License Edit opam file Versions (7)

Authors

J

Jane Street Group, LLC

Maintainers

J

Jane Street developers

Sources

async_unix-v0.16.0.tar.gz

sha256=a6a86202acea433b5c739ac20190a9a364da9d9eb7ebd402f517b8c58983839b

doc/async_unix/Async_unix/Signal/index.html

Module `Async_unix.Signal`Source

Signal handling.

To discourage use of the Signal.Expert module, we hide it here. People can use Core.Signal.Expert if they need.

include module type of Core.Signal
  with type t = Core.Signal.t
  with module Expert := Core.Signal.Expert

Sourcetype t = Core.Signal.t

include Bin_prot.Binable.S with type t := t

include Bin_prot.Binable.S_only_functions with type t := t

Sourceval bin_size_t : t Bin_prot.Size.sizer

Sourceval bin_write_t : t Bin_prot.Write.writer

Sourceval bin_read_t : t Bin_prot.Read.reader

Sourceval __bin_read_t__ : (int -> t) Bin_prot.Read.reader

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

Sourceval bin_shape_t : Bin_prot.Shape.t

Sourceval bin_writer_t : t Bin_prot.Type_class.writer

Sourceval bin_reader_t : t Bin_prot.Type_class.reader

Sourceval bin_t : t Bin_prot.Type_class.t

include Sexplib0.Sexpable.S with type t := t

Sourceval t_of_sexp : Sexplib0.Sexp.t -> t

Sourceval sexp_of_t : t -> Sexplib0.Sexp.t

include Core.Comparable.S with type t := t

include Base.Comparable.S with type t := t

val (>=) : t -> t -> bool

val (<=) : t -> t -> bool

val (=) : t -> t -> bool

val (>) : t -> t -> bool

val (<) : t -> t -> bool

val (<>) : t -> t -> bool

val min : t -> t -> t

val max : t -> t -> t

val ascending : t -> t -> int

ascending is identical to compare. descending x y = ascending y x. These are intended to be mnemonic when used like List.sort ~compare:ascending and List.sort ~cmp:descending, since they cause the list to be sorted in ascending or descending order, respectively.

val descending : t -> t -> int

val between : t -> low:t -> high:t -> bool

between t ~low ~high means low <= t <= high

val clamp_exn : t -> min:t -> max:t -> t

clamp_exn t ~min ~max returns t', the closest value to t such that between t' ~low:min ~high:max is true.

Raises if not (min <= max).

val clamp : t -> min:t -> max:t -> t Base__.Or_error.t

type comparator_witness = Core.Signal.comparator_witness

val comparator : (t, comparator_witness) Base__.Comparator.comparator

Sourceval validate_lbound : min:t Core.Maybe_bound.t -> t Validate.check

Sourceval validate_ubound : max:t Core.Maybe_bound.t -> t Validate.check

Source

val validate_bound : 
  min:t Core.Maybe_bound.t ->
  max:t Core.Maybe_bound.t ->
  t Validate.check

Sourcemodule Replace_polymorphic_compare = Core.Signal.Replace_polymorphic_compare

Sourcemodule Map = Core.Signal.Map

Sourcemodule Set = Core.Signal.Set

include Core.Hashable.S with type t := t

include Ppx_compare_lib.Comparable.S with type t := t

val compare : t Base__Ppx_compare_lib.compare

include Ppx_hash_lib.Hashable.S with type t := t

val hash_fold_t : t Base__Ppx_hash_lib.hash_fold

val hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_value

val hashable : t Core.Hashtbl.Hashable.t

Sourcemodule Table = Core.Signal.Table

Sourcemodule Hash_set = Core.Signal.Hash_set

Sourcemodule Hash_queue = Core.Signal.Hash_queue

include Base.Stringable.S with type t := t

Sourceval of_string : string -> t

Sourceval equal : t -> t -> Base.Bool.t

Sourceval of_caml_int : Base.Int.t -> t

of_caml_int constructs a Signal.t given an OCaml internal signal number. This is only for the use of the Core_unix module.

Sourceval to_caml_int : t -> Base.Int.t

Sourceval to_string : t -> Base.String.t

to_string t returns a human-readable name: "sigabrt", "sigalrm", ...

Sourcetype sys_behavior = [

| `Continue
(*
Continue the process if it is currently stopped
*)
| `Dump_core
(*
Terminate the process and dump core
*)
| `Ignore
(*
Ignore the signal
*)
| `Stop
(*
Stop (suspend) the process
*)
| `Terminate
(*
Terminate the process
*)

]

The behaviour of the system if a signal is received by a process. See include/linux/kernel.h in the Linux kernel source tree (not the file /usr/include/linux/kernel.h).

Sourceval sexp_of_sys_behavior : sys_behavior -> Sexplib0.Sexp.t

Sourceval sys_behavior_of_sexp : Sexplib0.Sexp.t -> sys_behavior

Sourceval __sys_behavior_of_sexp__ : Sexplib0.Sexp.t -> sys_behavior

Sourceval default_sys_behavior : t -> sys_behavior

Queries the default system behavior for a signal.

Specific signals, along with their default behavior and meaning.

Sourceval abrt : t

Dump_core Abnormal termination

Sourceval alrm : t

Terminate Timeout

Sourceval bus : t

Dump_core Bus error

Sourceval chld : t

Ignore Child process terminated

Sourceval cont : t

Continue Continue

Sourceval fpe : t

Dump_core Arithmetic exception

Sourceval hup : t

Terminate Hangup on controlling terminal

Sourceval ill : t

Dump_core Invalid hardware instruction

Sourceval int : t

Terminate Interactive interrupt (ctrl-C)

Sourceval kill : t

Terminate Termination (cannot be ignored)

Sourceval pipe : t

Terminate Broken pipe

Sourceval poll : t

Terminate Pollable event

Sourceval prof : t

Terminate Profiling interrupt

Sourceval quit : t

Dump_core Interactive termination

Sourceval segv : t

Dump_core Invalid memory reference

Sourceval sys : t

Dump_core Bad argument to routine

Sourceval stop : t

Stop Stop

Sourceval term : t

Terminate Termination

Sourceval trap : t

Dump_core Trace/breakpoint trap

Sourceval tstp : t

Stop Interactive stop

Sourceval ttin : t

Stop Terminal read from background process

Sourceval ttou : t

Stop Terminal write from background process

Sourceval urg : t

Ignore Urgent condition on socket

Sourceval usr1 : t

Terminate Application-defined signal 1

Sourceval usr2 : t

Terminate Application-defined signal 2

Sourceval vtalrm : t

Terminate Timeout in virtual time

Sourceval xcpu : t

Dump_core Timeout in cpu time

Sourceval xfsz : t

Dump_core File size limit exceeded

Sourceval zero : t

Ignore No-op; can be used to test whether the target process exists and the current process has permission to signal it

Sourcetype pid_spec = [

| `Use_Signal_unix

]

deprecated [since 2021-04] Use [Signal_unix]

Sourcetype sigprocmask_command = [

| `Use_Signal_unix

]

deprecated [since 2021-04] Use [Signal_unix]

Sourceval can_send_to : [ `Use_Signal_unix ]

deprecated [since 2021-04] Use [Signal_unix]

Sourceval of_system_int : [ `Use_Signal_unix ]

deprecated [since 2021-04] Use [Signal_unix]

Sourceval send : [ `Use_Signal_unix ]

deprecated [since 2021-04] Use [Signal_unix]

Sourceval send_exn : [ `Use_Signal_unix ]

deprecated [since 2021-04] Use [Signal_unix]

Sourceval send_i : [ `Use_Signal_unix ]

deprecated [since 2021-04] Use [Signal_unix]

Sourceval sexp_of_pid_spec : [ `Use_Signal_unix ]

deprecated [since 2021-04] Use [Signal_unix]

Sourceval sigpending : [ `Use_Signal_unix ]

deprecated [since 2021-04] Use [Signal_unix]

Sourceval sigprocmask : [ `Use_Signal_unix ]

deprecated [since 2021-04] Use [Signal_unix]

Sourceval sigsuspend : [ `Use_Signal_unix ]

deprecated [since 2021-04] Use [Signal_unix]

Sourceval to_system_int : [ `Use_Signal_unix ]

deprecated [since 2021-04] Use [Signal_unix]

Sourcemodule Stable = Core.Signal.Stable

Sourceval handle_default : [ `Do_not_use_with_async ] -> _

We override values from Core.Signal that we don't want people to use with Async.

Sourceval ignore : [ `Do_not_use_with_async ] -> _

Source

val handle : 
  ?stop:unit Async_kernel.Deferred.t ->
  t list ->
  f:(t -> unit) ->
  unit

handle ?stop signals ~f arranges so that whenever a signal in signals is delivered, f is called on that signal. If f raises, then an exception will be raised to the monitor in effect when handle was called.

Multiple calls to handle with the same signal will cause all the handlers to run when that signal is delivered, not just the last handler from the last call to handle.

The first time handle is called for a signal, it will install a C signal handler for it, replacing the existing C signal handler for that signal.

If stop is passed, the signal handler will be uninstalled when stop resolves.

Sourceval terminating : t list

terminating is a list of signals that can be supplied to handle and whose default behavior is to terminate the program: alrm hup int term usr1 usr2.

Various signals whose default_sys_behavior is `Terminate are not included:

   | kill   | it's not allowed to be handled                            |
   | pipe   | Async already ignores this signal, since it handles EPIPE |
   | prof   | so that we can profile things with -p                     |
   | vtalrm | it already has a handler                                  |

Sourceval is_managed_by_async : t -> bool

is_managed_by_async signal returns true iff signal is being managed by Async, and hence its default behavior is no longer in effect.