Provided by: erlang-manpages_24.3.4.1+dfsg-1_all 
NAME
erpc - Enhanced Remote Procedure Call
DESCRIPTION
This module provide services similar to Remote Procedure Calls. A remote procedure call is
a method to call a function on a remote node and collect the answer. It is used for
collecting information on a remote node, or for running a function with some specific side
effects on the remote node.
This is an enhanced subset of the operations provided by the rpc module. Enhanced in the
sense that it makes it possible to distinguish between returned value, raised exceptions,
and other errors. erpc also has better performance and scalability than the original rpc
implementation. However, current rpc module will utilize erpc in order to also provide
these properties when possible.
In order for an erpc operation to succeed, the remote node also needs to support erpc.
Typically only ordinary Erlang nodes as of OTP 23 have erpc support.
Note that it is up to the user to ensure that correct code to execute via erpc is
available on the involved nodes.
DATA TYPES
request_id()
An opaque type of call request identifiers. For more information see
send_request/4.
EXPORTS
call(Node, Fun) -> Result
call(Node, Fun, Timeout) -> Result
Types:
Node = node()
Fun = function()
Timeout = 0..4294967295 | infinity
Result = term()
The same as calling erpc:call(Node,erlang,apply,[Fun,[]],Timeout). May raise all
the same exceptions as erpc:call/5 plus an {erpc, badarg} error exception if Fun is
not a fun of zero arity.
The call erpc:call(Node,Fun) is the same as the call erpc:call(Node,Fun,infinity).
call(Node, Module, Function, Args) -> Result
call(Node, Module, Function, Args, Timeout) -> Result
Types:
Node = node()
Module = Function = atom()
Args = [term()]
Timeout = 0..4294967295 | infinity
Result = term()
Evaluates apply(Module, Function, Args) on node Node and returns the corresponding
value Result. Timeout is an integer representing the timeout in milliseconds or the
atom infinity which prevents the operation from ever timing out.
The call erpc:call(Node, Module, Function, Args) is equivalent to the call
erpc:call(Node, Module, Function, Args, infinity)
The call() function only returns if the applied function successfully returned
without raising any uncaught exceptions, the operation did not time out, and no
failures occurred. In all other cases an exception is raised. The following
exceptions, listed by exception class, can currently be raised by erpc:call():
throw:
The applied function called throw(Value) and did not catch this exception. The
exception reason Value equals the argument passed to throw/1.
exit:
Exception reason:
{exception, ExitReason}:
The applied function called exit(ExitReason) and did not catch this
exception. The exit reason ExitReason equals the argument passed to exit/1.
{signal, ExitReason}:
The process that applied the function received an exit signal and terminated
due to this signal. The process terminated with exit reason ExitReason.
error:
Exception reason:
{exception, ErrorReason, StackTrace}:
A runtime error occurred which raised and error exception while applying the
function, and the applied function did not catch the exception. The error
reason ErrorReason indicates the type of error that occurred. StackTrace is
formatted as when caught in a try/catch construct. The StackTrace is limited
to the applied function and functions called by it.
{erpc, ERpcErrorReason}:
The erpc operation failed. The following ERpcErrorReasons are the most common
ones:
badarg:
If any one of these are true:
* Node is not an atom.
* Module is not an atom.
* Function is not an atom.
* Args is not a list. Note that the list is not verified to be a proper
list at the client side.
* Timeout is not the atom infinity or an integer in valid range.
noconnection:
The connection to Node was lost or could not be established. The function
may or may not be applied.
system_limit:
The erpc operation failed due to some system limit being reached. This
typically due to failure to create a process on the remote node Node, but
can be other things as well.
timeout:
The erpc operation timed out. The function may or may not be applied.
notsup:
The remote node Node does not support this erpc operation.
If the erpc operation fails, but it is unknown if the function is/will be applied
(that is, a timeout or a connection loss), the caller will not receive any further
information about the result if/when the applied function completes. If the applied
function explicitly communicates with the calling process, such communication may,
of course, reach the calling process.
Note:
You cannot make any assumptions about the process that will perform the apply(). It
may be the calling process itself, a server, or a freshly spawned process.
cast(Node, Fun) -> ok
Types:
Node = node()
Fun = function()
The same as calling erpc:cast(Node,erlang,apply,[Fun,[]]).
erpc:cast/2 fails with an {erpc, badarg} error exception if:
* Node is not an atom.
* Fun is not a a fun of zero arity.
cast(Node, Module, Function, Args) -> ok
Types:
Node = node()
Module = Function = atom()
Args = [term()]
Evaluates apply(Module, Function, Args) on node Node. No response is delivered to
the calling process. erpc:cast() returns immediately after the cast request has
been sent. Any failures beside bad arguments are silently ignored.
erpc:cast/4 fails with an {erpc, badarg} error exception if:
* Node is not an atom.
* Module is not an atom.
* Function is not an atom.
* Args is not a list. Note that the list is not verified to be a proper list at
the client side.
Note:
You cannot make any assumptions about the process that will perform the apply(). It
may be a server, or a freshly spawned process.
check_response(Message, RequestId) ->
{response, Result} | no_response
Types:
Message = term()
RequestId = request_id()
Result = term()
Check if a message is a response to a call request previously made by the calling
process using erpc:send_request/4. RequestId should be the value returned from the
previously made erpc:send_request() call, and the corresponding response should not
already have been received and handled to completion by erpc:check_response(),
erpc:receive_response(), or erpc:wait_response(). Message is the message to check.
If Message does not correspond to the response, the atom no_response is returned.
If Message corresponds to the response, the call operation is completed and either
the result is returned as {response, Result} where Result corresponds to the value
returned from the applied function or an exception is raised. The exceptions that
can be raised corresponds to the same exceptions as can be raised by erpc:call/4.
That is, no {erpc, timeout} error exception can be raised. erpc:check_response()
will fail with an {erpc, badarg} exception if/when an invalid RequestId is
detected.
If the erpc operation fails, but it is unknown if the function is/will be applied
(that is, a connection loss), the caller will not receive any further information
about the result if/when the applied function completes. If the applied function
explicitly communicates with the calling process, such communication may, of
course, reach the calling process.
multicall(Nodes, Fun) -> Result
multicall(Nodes, Fun, Timeout) -> Result
Types:
Nodes = [atom()]
Fun = function()
Timeout = 0..4294967295 | infinity
Result = term()
The same as calling erpc:multicall(Nodes,erlang,apply,[Fun,[]],Timeout). May raise
all the same exceptions as erpc:multicall/5 plus an {erpc, badarg} error exception
if Fun is not a fun of zero arity.
The call erpc:multicall(Nodes,Fun) is the same as the call
erpc:multicall(Nodes,Fun, infinity).
multicall(Nodes, Module, Function, Args) -> Result
multicall(Nodes, Module, Function, Args, Timeout) -> Result
Types:
Nodes = [atom()]
Module = Function = atom()
Args = [term()]
Timeout = 0..4294967295 | infinity
Result =
[{ok, ReturnValue :: term()} | caught_call_exception()]
caught_call_exception() =
{throw, Throw :: term()} |
{exit, {exception, Reason :: term()}} |
{error,
{exception, Reason :: term(), StackTrace :: [stack_item()]}} |
{exit, {signal, Reason :: term()}} |
{error, {erpc, Reason :: term()}}
stack_item() =
{Module :: atom(),
Function :: atom(),
Arity :: arity() | (Args :: [term()]),
Location ::
[{file, Filename :: string()} |
{line, Line :: integer() >= 1}]}
Performs multiple call operations in parallel on multiple nodes. That is, evaluates
apply(Module, Function, Args) on the nodes Nodes in parallel. Timeout is an integer
representing the timeout in milliseconds or the atom infinity which prevents the
operation from ever timing out. The result is returned as a list where the result
from each node is placed at the same position as the node name is placed in Nodes.
Each item in the resulting list is formatted as either:
{ok, Result}:
The call operation for this specific node returned Result.
{Class, ExceptionReason}:
The call operation for this specific node raised an exception of class Class
with exception reason ExceptionReason. These corresponds the the exceptions
that erpc:call/5 can raise.
erpc:multicall/5 fails with an {erpc, badarg} error exception if:
* Nodes is not a proper list of atoms. Note that some requests may already have
been sent when the failure occurs. That is, the function may or may not be
applied on some nodes.
* Module is not an atom.
* Function is not an atom.
* Args is not a list. Note that the list is not verified to be a proper list at
the client side.
The call erpc:multicall(Nodes, Module, Function, Args) is equivalent to the call
erpc:multicall(Nodes, Module, Function, Args, infinity). These calls are also
equivalent to calling my_multicall(Nodes, Module, Function, Args) if one disregard
performance and failure behavior:
my_multicall(Nodes, Module, Function, Args) ->
ReqIds = lists:map(fun (Node) ->
erpc:send_request(Node, Module, Function, Args)
end,
Nodes),
lists:map(fun (ReqId) ->
try
{ok, erpc:receive_response(ReqId, infinity)}
catch
Class:Reason ->
{Class, Reason}
end
end,
ReqIds).
The Timeout value in milliseconds sets an upper time limit for all call operations
to complete.
If an erpc operation fails, but it is unknown if the function is/will be applied
(that is, a timeout, connection loss, or an improper Nodes list), the caller will
not receive any further information about the result if/when the applied function
completes. If the applied function communicates with the calling process, such
communication may, of course, reach the calling process.
Note:
You cannot make any assumptions about the process that will perform the apply(). It
may be the calling process itself, a server, or a freshly spawned process.
multicast(Nodes, Fun) -> ok
Types:
Nodes = [node()]
Fun = function()
The same as calling erpc:multicast(Nodes,erlang,apply,[Fun,[]]).
erpc:multicast/2 fails with an {erpc, badarg} error exception if:
* Nodes is not a proper list of atoms.
* Fun is not a a fun of zero arity.
multicast(Nodes, Module, Function, Args) -> ok
Types:
Nodes = [node()]
Module = Function = atom()
Args = [term()]
Evaluates apply(Module, Function, Args) on the nodes Nodes. No response is
delivered to the calling process. erpc:multicast() returns immediately after the
cast requests have been sent. Any failures beside bad arguments are silently
ignored.
erpc:multicast/4 fails with an {erpc, badarg} error exception if:
* Nodes is not a proper list of atoms. Note that some requests may already have
been sent when the failure occurs. That is, the function may or may not be
applied on some nodes.
* Module is not an atom.
* Function is not an atom.
* Args is not a list. Note that the list is not verified to be a proper list at
the client side.
Note:
You cannot make any assumptions about the process that will perform the apply(). It
may be a server, or a freshly spawned process.
receive_response(RequestId) -> Result
receive_response(RequestId, Timeout) -> Result
Types:
RequestId = request_id()
Timeout = 0..4294967295 | infinity
Result = term()
Receive a response to a call request previously made by the calling process using
erpc:send_request/4. RequestId should be the value returned from the previously
made erpc:send_request() call, and the corresponding response should not already
have been received and handled to completion by erpc:check_response(),
erpc:receive_response(), or erpc:wait_response(). Timeout is an integer
representing the timeout in milliseconds or the atom infinity which prevents the
operation from ever timing out. The call operation is completed once the
erpc:receive_response() call returns or raise an exception.
The call erpc:receive_response(RequestId) is equivalent to the call
erpc:receive_response(RequestId, infinity).
A call to the function my_call(Node, Module, Function, Args, Timeout) below is
equivalent to the call erpc:call(Node, Module, Function, Args, Timeout) if one
disregards performance. erpc:call() can utilize a message queue optimization which
removes the need to scan the whole message queue which the combination
erpc:send_request()/erpc:receive_response() cannot.
my_call(Node, Module, Function, Args, Timeout) ->
RequestId = erpc:send_request(Node, Module, Function, Args),
erpc:receive_response(RequestId, Timeout).
If the erpc operation fails, but it is unknown if the function is/will be applied
(that is, a timeout, or a connection loss), the caller will not receive any further
information about the result if/when the applied function completes. If the applied
function explicitly communicates with the calling process, such communication may,
of course, reach the calling process.
erpc:receive_response() will return or raise exceptions the same way as erpc:call/5
does with the exception of {erpc, badarg}. An {erpc, badarg} exception will be
raised if/when an invalid RequestId is detected or if an invalid Timeout is passed.
send_request(Node, Fun) -> RequestId
Types:
Node = node()
Fun = function()
RequestId = request_id()
The same as calling erpc:send_request(Node,erlang,apply,[Fun,[]]).
erpc:send_request/2 fails with an {erpc, badarg} error exception if:
* Node is not an atom.
* Fun is not a fun of zero arity.
Note:
You cannot make any assumptions about the process that will perform the apply(). It
may be a server, or a freshly spawned process.
send_request(Node, Module, Function, Args) -> RequestId
Types:
Node = node()
Module = Function = atom()
Args = [term()]
RequestId = request_id()
Send an asynchronous call request to the node Node. erpc:send_request() returns a
request identifier that later is to be passed as argument to either
erpc:receive_response(), erpc:wait_response(), or, erpc:check_response() in order
to get the response of the call request.
erpc:send_request() fails with an {erpc, badarg} error exception if:
* Node is not an atom.
* Module is not an atom.
* Function is not an atom.
* Args is not a list. Note that the list is not verified to be a proper list at
the client side.
wait_response(RequestId) -> {response, Result} | no_response
wait_response(RequestId, WaitTime) ->
{response, Result} | no_response
Types:
RequestId = request_id()
WaitTime = 0..4294967295 | infinity
Result = term()
Wait or poll for a response message to a call request previously made by the
calling process using erpc:send_request/4. RequestId should be the value returned
from the previously made erpc:send_request() call, and the corresponding response
should not already have been received and handled to completion by
erpc:check_response(), erpc:receive_response(), or erpc:wait_response(). WaitTime
equals the time to wait in milliseconds (or the atom infinity) during the wait.
WaitTime is an integer representing time to wait in milliseconds or the atom
infinity which will cause wait_response/2 to wait for a response until it appears
regardless of how long time that is.
The call erpc:wait_response(RequestId) is equivalent to the call
erpc:wait_response(RequestId, 0). That is, poll for a response message to a call
request previously made by the calling process.
If no response is received before WaitTime milliseconds, the atom no_response is
returned. It is valid to continue waiting for a response as many times as needed up
until a response has been received and completed by erpc:check_response(),
erpc:receive_response(), or erpc:wait_response(). If a response is received, the
call operation is completed and either the result is returned as {response, Result}
where Result corresponds to the value returned from the applied function or an
exception is raised. The exceptions that can be raised corresponds to the same
exceptions as can be raised by erpc:call/4. That is, no {erpc, timeout} error
exception can be raised. erpc:wait_response() will fail with an {erpc, badarg}
exception if/when an invalid RequestId is detected or if an invalid WaitTime is
passed.
If the erpc operation fails, but it is unknown if the function is/will be applied
(that is, a too large wait time value, or a connection loss), the caller will not
receive any further information about the result if/when the applied function
completes. If the applied function explicitly communicates with the calling
process, such communication may, of course, reach the calling process.