partisan_erpc (partisan v5.0.1)

View Source

This module is an adaptation of Erlang erpc module.

It replaces all instances of erlang:send/2` and `erlang:monitor/2` with their Partisan counterparts. It maintains the `erpc API with the following exceptions:

    TODO - Channels

    NOTICE: At the moment this only works for partisan_pluggable_peer_service_manager.

    Summary

    Types

    caught_call_exception/0

    -type caught_call_exception() ::
              {throw, Throw :: term()} |
              {exit, {exception, Reason :: term()}} |
              {error, {exception, Reason :: term(), StackTrace :: [stack_item()]}} |
              {exit, {signal, Reason :: term()}} |
              {error, {partisan_erpc, Reason :: term()}}.

    request_id/0

    -opaque request_id()

    stack_item/0

    -type stack_item() ::
              {Module :: atom(),
               Function :: atom(),
               Arity :: arity() | (Args :: [term()]),
               Location :: [{file, Filename :: string()} | {line, Line :: pos_integer()}]}.

    Functions

    call(Node, Fun)

    -spec call(Node, Fun) -> Result when Node :: node(), Fun :: function(), Result :: term().

    call(Node, Fun, Timeout)

    -spec call(Node, Fun, Timeout) -> Result
                  when
                      Node :: node(),
                      Fun :: function(),
                      Timeout :: 0..4294967295 | infinity,
                      Result :: term().

    call(Node, Module, Function, Args)

    -spec call(Node, Module, Function, Args) -> Result
                  when
                      Node :: node(),
                      Module :: atom(),
                      Function :: atom(),
                      Args :: [term()],
                      Result :: term().

    call(Node, Module, Function, Args, Timeout)

    -spec call(Node, Module, Function, Args, Timeout) -> Result
                  when
                      Node :: node(),
                      Module :: atom(),
                      Function :: atom(),
                      Args :: [term()],
                      Timeout :: 0..4294967295 | infinity,
                      Result :: term().

    call_result(Type, ReqId, Res, Reason)

    cast(Node, Fun)

    -spec cast(Node, Fun) -> ok when Node :: node(), Fun :: function().

    cast(Node, Module, Function, Args)

    -spec cast(Node, Module, Function, Args) -> ok
                  when Node :: node(), Module :: atom(), Function :: atom(), Args :: [term()].

    check_response(Message, RequestId)

    -spec check_response(Message, RequestId) -> {response, Result} | no_response
                            when Message :: term(), RequestId :: request_id(), Result :: term().

    execute_call(M, F, A)

    execute_call(Ref, M, F, A)

    execute_cast(M, F, A)

    is_arg_error(R, M, F, A)

    multicall(Nodes, Fun)

    -spec multicall(Nodes, Fun) -> Result when Nodes :: [atom()], Fun :: function(), Result :: term().

    multicall(Nodes, Fun, Timeout)

    -spec multicall(Nodes, Fun, Timeout) -> Result
                       when
                           Nodes :: [atom()],
                           Fun :: function(),
                           Timeout :: 0..4294967295 | infinity,
                           Result :: term().

    multicall(Nodes, Module, Function, Args)

    -spec multicall(Nodes, Module, Function, Args) -> Result
                       when
                           Nodes :: [atom()],
                           Module :: atom(),
                           Function :: atom(),
                           Args :: [term()],
                           Result :: [{ok, ReturnValue :: term()} | caught_call_exception()].

    multicall(Nodes, Module, Function, Args, Timeout)

    -spec multicall(Nodes, Module, Function, Args, Timeout) -> Result
                       when
                           Nodes :: [atom()],
                           Module :: atom(),
                           Function :: atom(),
                           Args :: [term()],
                           Timeout :: 0..4294967295 | infinity,
                           Result :: [{ok, ReturnValue :: term()} | caught_call_exception()].

    multicast(Nodes, Fun)

    -spec multicast(Nodes, Fun) -> ok when Nodes :: [node()], Fun :: function().

    multicast(Nodes, Module, Function, Args)

    -spec multicast(Nodes, Module, Function, Args) -> ok
                       when Nodes :: [node()], Module :: atom(), Function :: atom(), Args :: [term()].

    receive_response(RequestId)

    -spec receive_response(RequestId) -> Result when RequestId :: request_id(), Result :: term().

    receive_response(RequestId, Timeout)

    -spec receive_response(RequestId, Timeout) -> Result
                              when
                                  RequestId :: request_id(),
                                  Timeout :: 0..4294967295 | infinity,
                                  Result :: term().

    send_request(Node, Fun)

    -spec send_request(Node, Fun) -> RequestId
                          when Node :: node(), Fun :: function(), RequestId :: request_id().

    send_request(Node, Module, Function, Args)

    -spec send_request(Node, Module, Function, Args) -> RequestId
                          when
                              Node :: node(),
                              Module :: atom(),
                              Function :: atom(),
                              Args :: [term()],
                              RequestId :: request_id().

    trim_stack(S, M, F, A)

    wait_response(RequestId)

    -spec wait_response(RequestId) -> {response, Result} | no_response
                           when RequestId :: request_id(), Result :: term().

    wait_response(RequestId, WaitTime)

    -spec wait_response(RequestId, WaitTime) -> {response, Result} | no_response
                           when
                               RequestId :: request_id(),
                               WaitTime :: 0..4294967295 | infinity,
                               Result :: term().