View Source Reactor.Middleware behaviour (reactor v0.9.1)

The Middleware behaviour.

By implementing this behaviour you can modify the internal state of the Reactor during startup, execution and shutdown.

Middlewares can be added to the reactor either with the middlewares DSL section or by the add_middleware/2, etc, functions in Reactor.Builder.

All callbacks in this behaviour are optional so you can define only the parts you need for your feature.

Summary

Types

context()

error_or_errors()

result()

step_event()

t()

Callbacks

complete(result, context)

The complete callback will be called with the successful result of the Reactor.

error(error_or_errors, context)

The error callback will be called the final error value(s) of the Reactor.

event(step_event, t, context)

Receive events about the execution of the Reactor.

get_process_context()

Called before starting an asynchronous step in order to retrieve any context information that needs to be passed into the new process.

halt(context)

The halt callback will be called with the Reactor context when halting.

init(context)

The init callback will be called with the Reactor context when starting up.

set_process_context(any)

Called inside a new asynchronous step in order to set context information into the new process.

Types

context()

@type context() :: Reactor.context()

error_or_errors()

@type error_or_errors() :: Exception.t() | [Exception.t()]

result()

@type result() :: any()

step_event()

@type step_event() ::
  :compensate_complete
  | :compensate_retry
  | :run_retry
  | :undo_complete
  | :undo_retry
  | :undo_start
  | {:compensate_continue, any()}
  | {:compensate_error, error_or_errors()}
  | {:compensate_retry, any()}
  | {:compensate_start, any()}
  | {:process_start, pid()}
  | {:process_terminate, pid()}
  | {:run_complete, result()}
  | {:run_error, error_or_errors()}
  | {:run_halt, any()}
  | {:run_retry, any()}
  | {:run_start, arguments :: Reactor.inputs()}
  | {:undo_error, error_or_errors()}
  | {:undo_retry, any()}

t()

@type t() :: module()

Callbacks

complete(result, context)

(optional)

@callback complete(result(), context()) :: {:ok, result()} | {:error, any()}

The complete callback will be called with the successful result of the Reactor.

This gives you the opportunity to modify the return value or to perform clean up of any non-reactor-managed resources (eg notifications).

Note that these callbacks are called in an arbitrary order meaning that the result value passed may have already been altered by another callback.

If any callback returns an error then any remaining callbacks will not be called.

error(error_or_errors, context)

(optional)

@callback error(error_or_errors(), context()) :: :ok | {:error, any()}

The error callback will be called the final error value(s) of the Reactor.

This gives you the opportunity to modify the return value or to perform clean up of any non-reactor-managed resources (eg notifications).

Note that these callbacks are called in an arbitrary order meaning that the error value passed may have already been altered by another callback.

Here a return value of :ok will continue calls to other callbacks without modifying the error value.

event(step_event, t, context)

(optional)

@callback event(step_event(), Reactor.Step.t(), Reactor.context()) :: :ok

Receive events about the execution of the Reactor.

This callback will block the Reactor, so it's encouraged that you do anything expensive in another process.

get_process_context()

(optional)

@callback get_process_context() :: any()

Called before starting an asynchronous step in order to retrieve any context information that needs to be passed into the new process.

This is most likely used by tracers to copy span information from the parent process to the child process.

halt(context)

(optional)

@callback halt(context()) :: {:ok, context()} | {:error, any()}

The halt callback will be called with the Reactor context when halting.

This allows you to clean up any non-reactor-managed resources or modify the context for later re-use by a future init/1 callback.

init(context)

(optional)

@callback init(context()) :: {:ok, context()} | {:error, any()}

The init callback will be called with the Reactor context when starting up.

This gives you the opportunity to modify the context or to perform any initialisation of any non-reactor-managed resources (eg notifications).

set_process_context(any)

(optional)

@callback set_process_context(any()) :: :ok

Called inside a new asynchronous step in order to set context information into the new process.

This is most likely used by tracers to copy span information from the parent process to the child process.