package core_unix

You can search for identifiers within the package.

in-package search v0.2.0

core_unix
- Core_unix
core_unix.bigbuffer_blocking
- Core_unix_bigbuffer_blocking
core_unix.bigstring_unix
- Core_unix_bigstring_unix
core_unix.command_unix
- Command_unix
core_unix.core_thread
- Core_thread
core_unix.daemon
- Core_unix_daemon
core_unix.date_unix
- Date_unix
core_unix.error_checking_mutex
- Core_unix_error_checking_mutex
core_unix.filename_unix
- Filename_unix
core_unix.interval_lib
- Interval_lib
core_unix.iobuf_unix
- Core_unix_iobuf_unix
core_unix.linux_ext
- Core_unix_linux_ext
core_unix.lock_file_blocking
- Core_unix_lock_file_blocking
core_unix.nano_mutex
- Core_unix_nano_mutex
core_unix.process_env
- Core_unix_process_env
core_unix.signal_unix
- Signal_unix
core_unix.squeue
- Core_unix_squeue
core_unix.sys_unix
- Sys_unix
core_unix.syslog
- Core_unix_syslog
core_unix.time_interface
- Time_interface
core_unix.time_ns_unix
- Time_ns_unix
core_unix.time_stamp_counter
- Core_unix_time_stamp_counter
core_unix.time_unix
- Time_unix
core_unix.uuid_unix
- Core_unix_uuid_unix

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of struct include Daemon end

module Fd_redirection = Daemon.Fd_redirection

val daemonize : 
  ?redirect_stdout:Fd_redirection.t ->
  ?redirect_stderr:Fd_redirection.t ->
  ?cd:string ->
  ?umask:int ->
  ?allow_threads_to_have_been_created:bool ->
  unit ->
  unit

daemonize makes the executing process a daemon.

The optional arguments have defaults as per daemonize_wait, below.

By default, output sent to stdout and stderr after daemonization will be silently eaten. This behaviour may be adjusted by using redirect_stdout and redirect_stderr. See the documentation for daemonize_wait below.

See daemonize_wait for a description of allow_threads_to_have_been_created.

Raises Failure if fork was unsuccessful.

val daemonize_wait : 
  ?redirect_stdout:Fd_redirection.t ->
  ?redirect_stderr:Fd_redirection.t ->
  ?cd:string ->
  ?umask:int ->
  ?allow_threads_to_have_been_created:bool ->
  unit ->
  (unit -> unit) Core.Staged.t

daemonize_wait makes the executing process a daemon, but delays full detachment from the calling shell/process until the returned "release" closure is called.

Any output to stdout/stderr before the "release" closure is called will get sent out normally. After "release" is called, stdin is connected to /dev/null, and stdout and stderr are connected as specified by redirect_stdout and redirect_stderr. The default is the usual behavior whereby both of these descriptors are connected to /dev/null. daemonize_wait, however, will not redirect stdout/stderr to /dev/null if they are already redirected to a regular file by default, i.e., default redirection is `Dev_null_skip_regular_files. This is to preserve behavior from earlier versions.)

Note that calling release will adjust SIGPIPE handling, so you should not rely on the delivery of this signal during this time.

daemonize_wait allows you to daemonize and then start asynchronously, but still have stdout/stderr go to the controlling terminal during startup. By default, when you daemonize, toplevel exceptions during startup would get sent to /dev/null. With daemonize_wait, toplevel exceptions can go to the terminal until you call release.

Forking (especially to daemonize) when running multiple threads is tricky and generally a mistake. daemonize and daemonize_wait check that the current number of threads is not greater than expected. daemonize_wait and daemonize also check that threads have not been created, which is more conservative than the actual requirement that multiple threads are not running. Using ~allow_threads_to_have_been_created:true bypasses that check. This is useful if Async was previously running, and therefore threads have been created, but has since been shut down. On non-Linux platforms, using ~allow_threads_to_have_been_created:true eliminates the protection daemonize and daemonize_wait have regarding threads.

Raises Failure if forking was unsuccessful.