Module Parallel.Make

module Worker = Make(T)

The Worker module has specialized functions to spawn workers and run functions on workers.

Parameters

Signature

type ('worker, 'query, 'response) _function
type t

A Worker.t type is defined with bin_io so it is possible to create functions that take a worker as an argument.

include Bin_prot.Binable.S with type t := t
type t
include Bin_prot.Binable.S_only_functions with type t := t
type t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __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.

val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
type worker = t

A type alias to make the Connection signature more readable

type 'a functions
val functions : t functions

Accessor for the functions implemented by this worker type

type worker_state_init_arg
type connection_state_init_arg
module Id : Core.Identifiable
val id : t -> Id.t
val serve : ?⁠max_message_size:int -> ?⁠handshake_timeout:Core.Time.Span.t -> ?⁠heartbeat_config:Async.Rpc.Connection.Heartbeat_config.t -> worker_state_init_arg -> worker Async.Deferred.t

serve arg will start an Rpc server in process implementing all the functions of the given worker.

module Connection : sig ... end
module Shutdown_on : functor (M : Core.T1) -> sig ... end
type 'a with_spawn_args = ?⁠where:Rpc_parallel.Executable_location.t -> ?⁠name:string -> ?⁠env:(string * string) list -> ?⁠connection_timeout:Core.Time.Span.t -> ?⁠cd:string -> on_failure:(Core.Error.t -> unit) -> 'a

The various spawn functions create a new worker process that implements the functions specified in the Worker_spec.

name will be attached to certain error messages and is useful for debugging.

env extends the environment of the spawned worker process.

connection_timeout is used for various internal timeouts. This may need be to increased if the init arg is really large (serialization and deserialization takes more than connection_timeout).

cd changes the current working directory of a spawned worker process.

shutdown_on specifies when a worker should shut itself down.

on_failure exn will be called in the spawning process upon the worker process raising a background exception. All exceptions raised before functions return will be returned to the caller. on_failure will be called in Monitor.current () at the time of this spawn call. The worker initiates shutdown upon sending the exception to the master process.

worker_state_init_arg (below) will be passed to init_worker_state of the given Worker_spec module. This initializes a persistent worker state for all connections to this worker.

val spawn : (?⁠umask:int -> shutdown_on:'a Shutdown_on(Core.Or_error).t -> redirect_stdout:Rpc_parallel.Fd_redirection.t -> redirect_stderr:Rpc_parallel.Fd_redirection.t -> worker_state_init_arg -> 'a) with_spawn_args

The spawned worker process daemonizes. Any initialization errors that wrote to stderr (Rpc_parallel internal initialization, not user initialization code) will be captured and rewritten to the spawning process's stderr with the prefix "WORKER %NAME% STDERR".

redirect_stdout and redirect_stderr specify stdout and stderr of the worker process.

val spawn_exn : (?⁠umask:int -> shutdown_on:'a Shutdown_on(Core.Monad.Ident).t -> redirect_stdout:Rpc_parallel.Fd_redirection.t -> redirect_stderr:Rpc_parallel.Fd_redirection.t -> worker_state_init_arg -> 'a) with_spawn_args
module Spawn_in_foreground_result : sig ... end
val spawn_in_foreground : (shutdown_on:'a Shutdown_on(Spawn_in_foreground_result).t -> worker_state_init_arg -> 'a) with_spawn_args

Similar to spawn but the worker process does not daemonize. If the process was spawned on a remote host, the ssh Process.t is returned.

Remember to call Process.wait on the returned Process.t to avoid zombie processes.

module Spawn_in_foreground_exn_result : sig ... end
val spawn_in_foreground_exn : (shutdown_on:'a Shutdown_on(Spawn_in_foreground_exn_result).t -> worker_state_init_arg -> 'a) with_spawn_args
val shutdown : t -> unit Core.Or_error.t Async.Deferred.t

shutdown attempts to connect to a worker. Upon success, Shutdown.shutdown 0 is run in the worker. If you want strong guarantees that a worker did shutdown, consider using spawn_in_foreground and inspecting the Process.t.

module Deprecated : sig ... end
module For_internal_testing : sig ... end

This module is used for internal testing of the rpc_parallel library.