riot 0.0.9 (latest) · OCaml Package

Riot

module Timeout : sig ... end

module Ref : sig ... end

module Pid : sig ... end

module Message : sig ... end

module Process : sig ... end

module Application : sig ... end

A Riot `Application` can be used to encapsulate functionality that must share the same lifecycle. For example, the `Riot.Logger` is an Application.

val random : unit -> Stdlib.Random.State.t

Returns the current random state from a scheduler.

val yield : unit -> unit

Suspends execution of the current process and returns control to the scheduler

val sleep : float -> unit

sleep t Suspends execution of the current process for at least `t` seconds. `t` is a float so it supports subsecond values: `0.001` is 1 millisecond.

val self : unit -> Pid.t

Returns the process identifier (pid) for the current process

val process_flag : Process.process_flag -> unit

val exit : Pid.t -> Process.exit_reason -> unit

Sends an exit signal to the process pid, to exit with reason exit_reason

val send : Pid.t -> Message.t -> unit

Sends a message to process with this pid.

exception Invalid_destination of string

val send_by_name : name:string -> Message.t -> unit

Sends a message to a process registered with name. If name is not a valid destination for a message, this function raises an Invalid_destination name exception.

val spawn : (unit -> unit) -> Pid.t

Spawns a new process.

val spawn_pinned : (unit -> unit) -> Pid.t

Spawns a new process using the current scheduler.

val spawn_link : (unit -> unit) -> Pid.t

Spawns a new process and links it to the current process before returning.

exception Name_already_registered of string * Pid.t

val register : string -> Pid.t -> unit

register name pid registers a process by a given name. The name will be uniquely associated to this process and attempting to register the same name twice will result in an exception Name_already_registered being raised.

val unregister : string -> unit

unregister name frees a name and allows it to be re-registered. If the name was not registered before, this operation does nothing.

exception Link_no_process of Pid.t

val link : Pid.t -> unit

Links the current process and the process pid together.

val monitor : Pid.t -> unit

monitor pid makes self () a monitor of pid.

When pid terminates, self () will receive a Processes.Messages.Monitor(Process_down(pid)) message.

val processes : unit -> (Pid.t * Process.t) Stdlib.Seq.t

`processes ()` will list all the processes currently alive.

val is_process_alive : Pid.t -> bool

Returns true if the process pid is still alive.

val wait_pids : Pid.t list -> unit

Await all processes in the list to termimante.

exception Receive_timeout

exception Syscall_timeout

val receive : 
  selector:(Message.t -> [ `select of 'msg | `skip ]) ->
  ?after:int64 ->
  ?ref:unit Ref.t ->
  unit ->
  'msg

receive () will return the first message in the process mailbox.

This function will suspend a process that has an empty mailbox, and the process will remain asleep until a message is delivered to it.

### Timed Receive

If a `after was passed, then `receive ~after ()` will wait up to after and raise an `Receive_timeout` exception that can be matched on.

This is useful to prevent deadlock of processes when receiving messages.

### Selective Receive

If a `selector` was passed, the `selector` function will be used to select if a message will be picked or if it will be skipped.

### Receive with Refs

If a `ref` was passed, then `receive ~ref ()` will skip all messages created before the creation of this `Ref.t` value, and will only return newer messages.

This is useful to skip the queue, but not remove any of the messages before it. Those messages will be delivered in-order in future calls to `receive ()`.

val receive_any : ?after:int64 -> ?ref:unit Ref.t -> unit -> Message.t

receive_any () behaves like receive but does not require a selector and instead will return any message in the mailbox.

val shutdown : ?status:int -> unit -> unit

Gracefully shuts down the runtime. Any non-yielding process will block this.

val run : ?rnd:Stdlib.Random.State.t -> ?workers:int -> (unit -> unit) -> unit

Start the Riot runtime using function main to boot the system

val on_error : [ `Msg of string ] -> int

val run_with_status : 
  ?rnd:Stdlib.Random.State.t ->
  ?workers:int ->
  on_error:('error -> int) ->
  (unit -> (int, 'error) Stdlib.result) ->
  unit

run_with_status ~on_error main starts the Riot runtime using function main to boot the system and handling errors with on_error.

main should return a result of either an exit code or an error. on_error should handle an error code appropriately, then return a status code.

val start : 
  ?rnd:Stdlib.Random.State.t ->
  ?workers:int ->
  apps:(module Application.Intf) list ->
  unit ->
  unit

Start the Riot runtime with a series of applications.

Each application will be started in the same order as specified, and if any application fails to start up, the system will be shutdown.

Once the applications are started, they will all be monitored until they are all terminated. Only then will the runtime shutdown.

module Gen_server : sig ... end

module Supervisor : sig ... end

module Dynamic_supervisor : sig ... end

module Telemetry : sig ... end

module Logger : sig ... end

module Fd : sig ... end

module IO : sig ... end

module File : sig ... end

module Net : sig ... end

module SSL : sig ... end

module Timer : sig ... end

module Bytestring : sig ... end

module Queue : sig ... end

module Hashmap : sig ... end

Riot's Hashmap is a process-safe implementation of a hash-table.

module Stream : sig ... end

module Task : sig ... end

module Store : sig ... end

module Crypto : sig ... end

module Runtime : sig ... end

package riot

Riot