ct_rpc — common_test v1.27.7

Search documentation of common_test

# ct_rpc (common_test v1.27.7)

View Source

`Common Test` specific layer on Erlang/OTP `rpc`.

# Summary

## Functions

app_node(App, Candidates)

From a set of candidate nodes determines which of them is running the application `App`. If none of the candidate nodes is running `App`, the function makes the test case calling this function to fail. This function is the same as calling `app_node(App, Candidates, true)`.

app_node(App, Candidates, FailOnBadRPC)

Same as `ct_rpc:app_node/2`, except that argument `FailOnBadRPC` determines if the search for a candidate node is to stop if `badrpc` is received at some point.

app_node(App, Candidates, FailOnBadRPC, Cookie)

Same as `ct_rpc:app_node/2`, except that argument `FailOnBadRPC` determines if the search for a candidate node is to stop if `badrpc` is received at some point.

call(Node, Module, Function, Args)

Equivalent to `call(Node, Module, Function, Args, infinity, [])`.

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

Evaluates `apply(Module, Function, Args)` on the node `Node`. Returns either whatever `Function` returns, or `{badrpc, Reason}` if the remote procedure call fails. If `Node` is `{Fun, FunArgs}`, applying `Fun` to `FunArgs` is to return a node name.

call(Node, Module, Function, Args, TimeOut, Cookie)

Evaluates `apply(Module, Function, Args)` on the node `Node`. Returns either whatever `Function` returns, or `{badrpc, Reason}` if the remote procedure call fails. If `Node` is `{Fun, FunArgs}`, applying `Fun` to `FunArgs` is to return a node name.

cast(Node, Module, Function, Args)

Evaluates `apply(Module, Function, Args)` on the node `Node`. No response is delivered and the process that makes the call is not suspended until the evaluation is completed as in the case of `call/3,4`. If `Node` is `{Fun, FunArgs}`, applying `Fun` to `FunArgs` is to return a node name.

cast(Node, Module, Function, Args, Cookie)

Evaluates `apply(Module, Function, Args)` on the node `Node`. No response is delivered and the process that makes the call is not suspended until the evaluation is completed as in the case of `call/3,4`. If `Node` is `{Fun, FunArgs}`, applying `Fun` to `FunArgs` is to return a node name.

# Functions

# app_node(App, Candidates)

    -spec app_node(App, Candidates) -> CandidateNode
                      when App :: atom(), Candidates :: [node()], CandidateNode :: node().

From a set of candidate nodes determines which of them is running the application `App`. If none of the candidate nodes is running `App`, the function makes the test case calling this function to fail. This function is the same as calling `app_node(App, Candidates, true)`.

# app_node(App, Candidates, FailOnBadRPC)

    -spec app_node(App, Candidates, FailOnBadRPC) -> CandidateNode
                      when
                          App :: atom(),
                          Candidates :: [node()],
                          FailOnBadRPC :: boolean(),
                          CandidateNode :: node().

Same as `ct_rpc:app_node/2`, except that argument `FailOnBadRPC` determines if the search for a candidate node is to stop if `badrpc` is received at some point.

# app_node(App, Candidates, FailOnBadRPC, Cookie)

    -spec app_node(App, Candidates, FailOnBadRPC, Cookie) -> CandidateNode
                      when
                          App :: atom(),
                          Candidates :: [node()],
                          FailOnBadRPC :: boolean(),
                          Cookie :: atom() | [],
                          CandidateNode :: node().

Same as `ct_rpc:app_node/2`, except that argument `FailOnBadRPC` determines if the search for a candidate node is to stop if `badrpc` is received at some point.

The cookie on the client node is set to `Cookie` for this `rpc` operation (used to match the server node cookie).

# call(Node, Module, Function, Args)

    -spec call(Node, Module, Function, Args) -> term() | {badrpc, Reason}
                  when
                      Node :: {Function, Args} | node(),
                      Module :: module(),
                      Function :: atom(),
                      Args :: list(),
                      Reason :: term().

Equivalent to `call(Node, Module, Function, Args, infinity, [])`.

# call(Node, Module, Function, Args, TimeOut)

    -spec call(Node, Module, Function, Args, TimeOut) -> term() | {badrpc, Reason}
                  when
                      Node :: {Function, Args} | node(),
                      Module :: module(),
                      Function :: atom(),
                      Args :: list(),
                      TimeOut :: timeout(),
                      Reason :: term().

Evaluates `apply(Module, Function, Args)` on the node `Node`. Returns either whatever `Function` returns, or `{badrpc, Reason}` if the remote procedure call fails. If `Node` is `{Fun, FunArgs}`, applying `Fun` to `FunArgs` is to return a node name.

# call(Node, Module, Function, Args, TimeOut, Cookie)

    -spec call(Node, Module, Function, Args, TimeOut, Cookie) -> term() | {badrpc, Reason}
                  when
                      Node :: {Function, Args} | node(),
                      Module :: module(),
                      Function :: atom(),
                      Args :: list(),
                      TimeOut :: timeout(),
                      Cookie :: atom() | [],
                      Reason :: term().

Evaluates `apply(Module, Function, Args)` on the node `Node`. Returns either whatever `Function` returns, or `{badrpc, Reason}` if the remote procedure call fails. If `Node` is `{Fun, FunArgs}`, applying `Fun` to `FunArgs` is to return a node name.

The cookie on the client node is set to `Cookie` for this `rpc` operation (used to match the server node cookie).

# cast(Node, Module, Function, Args)

    -spec cast(Node, Module, Function, Args) -> ok
                  when
                      Node :: {Function, Args} | node(),
                      Module :: module(),
                      Function :: atom(),
                      Args :: list().

Evaluates `apply(Module, Function, Args)` on the node `Node`. No response is delivered and the process that makes the call is not suspended until the evaluation is completed as in the case of `call/3,4`. If `Node` is `{Fun, FunArgs}`, applying `Fun` to `FunArgs` is to return a node name.

# cast(Node, Module, Function, Args, Cookie)

    -spec cast(Node, Module, Function, Args, Cookie) -> ok
                  when
                      Node :: {Function, Args} | node(),
                      Module :: module(),
                      Function :: atom(),
                      Args :: list(),
                      Cookie :: atom() | [].

Evaluates `apply(Module, Function, Args)` on the node `Node`. No response is delivered and the process that makes the call is not suspended until the evaluation is completed as in the case of `call/3,4`. If `Node` is `{Fun, FunArgs}`, applying `Fun` to `FunArgs` is to return a node name.

The cookie on the client node is set to `Cookie` for this `rpc` operation (used to match the server node cookie).