Module rabbit_misc

Data Types

channel_or_connection_exit()

channel_or_connection_exit() = rabbit_types:channel_exit() | rabbit_types:connection_exit()

digraph_label()

digraph_label() = term()

graph_edge_fun()

graph_edge_fun() = fun(({atom(), [term()]}) -> [{digraph:vertex(), digraph:vertex()}])

graph_vertex_fun()

graph_vertex_fun() = fun(({atom(), [term()]}) -> [{digraph:vertex(), digraph_label()}])

ok_or_error()

ok_or_error() = rabbit_types:ok_or_error(any())

resource_name()

resource_name() = binary()

thunk()

thunk(T) = fun(() -> T)

tref()

tref() = {erlang, reference()} | {timer, timer:tref()}

Function Index

all_module_attributes/1
amqp_error/4
amqp_table/1
append_rpc_all_nodes/4
append_rpc_all_nodes/5
assert_args_equivalence/4
assert_field_equivalence/4
atom_to_binary/1
b64decode_or_throw/1
base64url/1
build_acyclic_graph/3
cancel_timer/1
ceil/1
check_expiry/1
compose_pid/4
confirm_to_sender/2
const/1
decompose_pid/1
dict_cons/3
die/1
dirty_dump_log/1
dirty_foreach_key/2
dirty_read/1
dirty_read_all/1
enable_cover/0
enable_cover/1
ensure_ok/2
ensure_timer/4
escape_html_tags/1
execute_mnesia_transaction/1
execute_mnesia_transaction/2
execute_mnesia_tx_with_tail/1
filter_exit_map/2
format/2
format_inet_error/1
format_many/1
format_message_queue/2
format_stderr/2
frame_error/2
gb_sets_difference/2
gb_trees_cons/3
gb_trees_fold/3
gb_trees_foreach/2
get_channel_operation_timeout/0
get_env/3
get_gc_info/1
get_parent/0
get_proc_name/0
group_proplists_by/2
interval_operation/5
is_abnormal_exit/1
is_os_process_alive/1
is_process_alive/1
is_regular_file/1
map_in_order/2
maps_cons/3
method_record_type/1
module_attributes_from_apps/2
moving_average/4
node_to_fake_pid/1
ntoa/1
ntoab/1
orddict_cons/3
os_cmd/1
otp_release/0
otp_system_version/0
parse_bool/1
parse_int/1
pget/2
pget/3
pget_or_die/2
pid_change_node/2
pid_to_string/1
platform_and_version/0
plmerge/2
pmerge/3
polite_pause/0
polite_pause/1
protocol_error/1
protocol_error/3
protocol_error/4
pset/3
pupdate/3
queue_fold/3
quit/1Halts the emulator returning the given status code to the os.
r/2
r/3
r_arg/4
rabbitmq_and_erlang_versions/0
rabbitmq_related_module_attributes/1
random/1
raw_read_file/1
report_cover/0
report_cover/1
rpc_call/4
rpc_call/5
rs/1
send_after/3
sequence_error/1
set_table_value/4
sort_field_table/1
start_cover/1
stop_timer/2
store_proc_name/1
store_proc_name/2
strict_version_minor_equivalent/2
string_to_pid/1
table_filter/3
table_lookup/2
tcp_name/3
throw_on_error/2
to_amqp_table/1
type_class/1
unfold/2
upmap/2
utf8_safe/1
version/0
version_compare/2
version_compare/3
version_minor_equivalent/2
which_applications/0
with_exit_handler/2
with_user/2

Function Details

all_module_attributes/1

all_module_attributes(Name::atom()) -> [{atom(), atom(), [term()]}]

amqp_error/4

amqp_error(Name::rabbit_framing:amqp_exception(), ExplanationFormat::string(), Params::[any()], Method::rabbit_framing:amqp_method_name()) -> rabbit_types:amqp_error()

amqp_table/1

amqp_table(Table) -> any()

append_rpc_all_nodes/4

append_rpc_all_nodes(Nodes::[node()], M::atom(), F::atom(), A::[any()]) -> [any()]

append_rpc_all_nodes/5

append_rpc_all_nodes(Nodes::[node()], M::atom(), F::atom(), A::[any()], Timeout::timeout()) -> [any()]

assert_args_equivalence/4

assert_args_equivalence(Orig::rabbit_framing:amqp_table(), New::rabbit_framing:amqp_table(), Name::rabbit_types:r(any()), Keys::[binary()]) -> ok | rabbit_types:connection_exit()

assert_field_equivalence/4

assert_field_equivalence(Current::any(), New::any(), Name::rabbit_types:r(any()), Key::atom() | binary()) -> ok | rabbit_types:connection_exit()

atom_to_binary/1

atom_to_binary(A) -> any()

b64decode_or_throw/1

b64decode_or_throw(B64) -> any()

base64url/1

base64url(In::binary()) -> string()

build_acyclic_graph/3

build_acyclic_graph(VertexFun::graph_vertex_fun(), EdgeFun::graph_edge_fun(), Graph::[{atom(), [term()]}]) -> rabbit_types:ok_or_error2(digraph:graph(), {vertex, duplicate, digraph:vertex()} | {edge, {bad_vertex, digraph:vertex()} | {bad_edge, [digraph:vertex()]}, digraph:vertex(), digraph:vertex()})

cancel_timer/1

cancel_timer(X1::tref()) -> ok

ceil/1

ceil(N::number()) -> integer()

check_expiry/1

check_expiry(N::integer()) -> rabbit_types:ok_or_error(any())

compose_pid/4

compose_pid(Node, Cre, Id, Ser) -> any()

confirm_to_sender/2

confirm_to_sender(Pid, MsgSeqNos) -> any()

const/1

const(A) -> thunk(A)

decompose_pid/1

decompose_pid(Pid) -> any()

dict_cons/3

dict_cons(Key::any(), Value::any(), Dict::dict:dict()) -> dict:dict()

die/1

die(Error::rabbit_framing:amqp_exception()) -> channel_or_connection_exit()

dirty_dump_log/1

dirty_dump_log(FileName::file:filename()) -> ok_or_error()

dirty_foreach_key/2

dirty_foreach_key(F::fun((any()) -> any()), TableName::atom()) -> ok | aborted

dirty_read/1

dirty_read(X1::{atom(), any()}) -> rabbit_types:ok_or_error2(any(), not_found)

dirty_read_all/1

dirty_read_all(TableName::atom()) -> [any()]

enable_cover/0

enable_cover() -> ok_or_error()

enable_cover/1

enable_cover(Dirs::[file:filename() | atom()]) -> ok_or_error()

ensure_ok/2

ensure_ok(X1::ok_or_error(), ErrorTag::atom()) -> ok

ensure_timer/4

ensure_timer(A, Idx::non_neg_integer(), After::non_neg_integer(), Msg::any()) -> A

escape_html_tags/1

escape_html_tags(S::string()) -> binary()

execute_mnesia_transaction/1

execute_mnesia_transaction(TxFun::thunk(A)) -> A

execute_mnesia_transaction/2

execute_mnesia_transaction(TxFun::thunk(A), PrePostCommitFun::fun((A, boolean()) -> B)) -> B

execute_mnesia_tx_with_tail/1

execute_mnesia_tx_with_tail(TxFun::thunk(fun((boolean()) -> B))) -> B | fun((boolean()) -> B)

filter_exit_map/2

filter_exit_map(F::fun((A) -> B), L::[A]) -> [B]

format/2

format(Fmt::string(), Args::[any()]) -> string()

format_inet_error/1

format_inet_error(E::atom()) -> string()

format_many/1

format_many(List::[{string(), [any()]}]) -> string()

format_message_queue/2

format_message_queue(Opt::any(), MQ::priority_queue:q()) -> term()

format_stderr/2

format_stderr(Fmt::string(), Args::[any()]) -> ok

frame_error/2

frame_error(MethodName::rabbit_framing:amqp_method_name(), BinaryFields::binary()) -> rabbit_types:connection_exit()

gb_sets_difference/2

gb_sets_difference(S1::gb_sets:set(), S2::gb_sets:set()) -> gb_sets:set()

gb_trees_cons/3

gb_trees_cons(Key::any(), Value::any(), Tree::gb_trees:tree()) -> gb_trees:tree()

gb_trees_fold/3

gb_trees_fold(Fun::fun((any(), any(), A) -> A), A, Tree::gb_trees:tree()) -> A

gb_trees_foreach/2

gb_trees_foreach(Fun::fun((any(), any()) -> any()), Tree::gb_trees:tree()) -> ok

get_channel_operation_timeout/0

get_channel_operation_timeout() -> non_neg_integer()

get_env/3

get_env(Application::atom(), Key::atom(), Def::term()) -> term()

get_gc_info/1

get_gc_info(Pid::pid()) -> [any()]

get_parent/0

get_parent() -> pid()

get_proc_name/0

get_proc_name() -> rabbit_types:proc_name()

group_proplists_by/2

group_proplists_by(KeyFun::fun((proplists:proplist()) -> any()), ListOfPropLists::[proplists:proplist()]) -> [[proplists:proplist()]]

interval_operation/5

interval_operation(X1::{atom(), atom(), any()}, MaxRatio::float(), MaxInterval::non_neg_integer(), IdealInterval::non_neg_integer(), LastInterval::non_neg_integer()) -> {any(), non_neg_integer()}

is_abnormal_exit/1

is_abnormal_exit(R::any()) -> boolean()

is_os_process_alive/1

is_os_process_alive(Pid::non_neg_integer()) -> boolean()

is_process_alive/1

is_process_alive(Pid::pid()) -> boolean()

is_regular_file/1

is_regular_file(Name) -> boolean()

map_in_order/2

map_in_order(F::fun((A) -> B), L::[A]) -> [B]

maps_cons/3

maps_cons(Key, Value, Map) -> any()

method_record_type/1

method_record_type(Record::rabbit_framing:amqp_method_record()) -> rabbit_framing:amqp_method_name()

module_attributes_from_apps/2

module_attributes_from_apps(Name, Apps) -> any()

moving_average/4

moving_average(Time::float(), HalfLife::float(), Next::float(), Current::float() | undefined) -> float()

node_to_fake_pid/1

node_to_fake_pid(Node::atom()) -> pid()

ntoa/1

ntoa(IP::inet:ip_address()) -> string()

ntoab/1

ntoab(IP::inet:ip_address()) -> string()

orddict_cons/3

orddict_cons(Key::any(), Value::any(), Dict::orddict:orddict()) -> orddict:orddict()

os_cmd/1

os_cmd(Command::string()) -> string()

otp_release/0

otp_release() -> string()

otp_system_version/0

otp_system_version() -> string()

parse_bool/1

parse_bool(V) -> any()

parse_int/1

parse_int(I) -> any()

pget/2

pget(K::term(), M::list() | map()) -> term()

pget/3

pget(K::term(), M::list() | map(), D::term()) -> term()

pget_or_die/2

pget_or_die(K::term(), M::list() | map()) -> term() | no_return()

pid_change_node/2

pid_change_node(Pid::pid(), NewNode::node()) -> pid()

pid_to_string/1

pid_to_string(Pid::pid()) -> string()

platform_and_version/0

platform_and_version() -> string()

plmerge/2

plmerge(P1::[term()], P2::[term()]) -> [term()]

pmerge/3

pmerge(Key::term(), Val::term(), List::[term()]) -> [term()]

polite_pause/0

polite_pause() -> done

polite_pause/1

polite_pause(N::non_neg_integer()) -> done

protocol_error/1

protocol_error(Amqp_error::rabbit_types:amqp_error()) -> channel_or_connection_exit()

protocol_error/3

protocol_error(Name::rabbit_framing:amqp_exception(), ExplanationFormat::string(), Params::[any()]) -> channel_or_connection_exit()

protocol_error/4

protocol_error(Name::rabbit_framing:amqp_exception(), ExplanationFormat::string(), Params::[any()], Method::rabbit_framing:amqp_method_name()) -> channel_or_connection_exit()

pset/3

pset(Key::term(), Value::term(), List::[term()]) -> [term()]

pupdate/3

pupdate(K, UpdateFun, P) -> any()

queue_fold/3

queue_fold(Fun::fun((any(), B) -> B), B, Q::queue:queue()) -> B

quit/1

quit(Status::integer()) -> no_return()

Halts the emulator returning the given status code to the os. On Windows this function will block indefinitely so as to give the io subsystem time to flush stdout completely.

r/2

r(VHostPath::rabbit_types:vhost(), K) -> rabbit_types:r3(rabbit_types:vhost(), K, '_')

r/3

r(Resource::rabbit_types:vhost() | rabbit_types:r(atom()), K, Name::resource_name()) -> rabbit_types:r3(rabbit_types:vhost(), K, resource_name())

r_arg/4

r_arg(Resource::rabbit_types:vhost() | rabbit_types:r(atom()), K, Table::rabbit_framing:amqp_table(), Key::binary()) -> undefined | rabbit_types:error({invalid_type, rabbit_framing:amqp_field_type()}) | rabbit_types:r(K)

rabbitmq_and_erlang_versions/0

rabbitmq_and_erlang_versions() -> {string(), string()}

rabbitmq_related_module_attributes/1

rabbitmq_related_module_attributes(Name) -> any()

random/1

random(N::non_neg_integer()) -> non_neg_integer()

raw_read_file/1

raw_read_file(Filename) -> {ok, Binary} | {error, Reason}

report_cover/0

report_cover() -> ok

report_cover/1

report_cover(Dirs::[file:filename() | atom()]) -> ok

rpc_call/4

rpc_call(Node::node(), Mod::atom(), Fun::atom(), Args::[any()]) -> any() | {badrpc, term()}

rpc_call/5

rpc_call(Node::node(), Mod::atom(), Fun::atom(), Args::[any()], Timeout::infinity | non_neg_integer()) -> any() | {badrpc, term()}

rs/1

rs(Resource::rabbit_types:r(atom())) -> string()

send_after/3

send_after(Millis::non_neg_integer(), Pid::pid(), Msg::any()) -> tref()

sequence_error/1

sequence_error(Rest::[{error, any()} | any()]) -> {error, any()} | any()

set_table_value/4

set_table_value(Table::rabbit_framing:amqp_table(), Key::binary(), Type::rabbit_framing:amqp_field_type(), Value::rabbit_framing:amqp_value()) -> rabbit_framing:amqp_table()

sort_field_table/1

sort_field_table(M::rabbit_framing:amqp_table()) -> rabbit_framing:amqp_table()

start_cover/1

start_cover(NodesS::[{string(), string()} | string()]) -> ok

stop_timer/2

stop_timer(A, Idx::non_neg_integer()) -> A

store_proc_name/1

store_proc_name(TypeProcName::rabbit_types:proc_type_and_name()) -> ok

store_proc_name/2

store_proc_name(Type::atom(), ProcName::rabbit_types:proc_name()) -> ok

strict_version_minor_equivalent/2

strict_version_minor_equivalent(A, B) -> any()

string_to_pid/1

string_to_pid(Str::string()) -> pid()

table_filter/3

table_filter(Pred::fun((A) -> boolean()), PrePostCommitFun::fun((A, boolean()) -> ok), TableName::atom()) -> [A]

table_lookup/2

table_lookup(Table::rabbit_framing:amqp_table(), Key::binary()) -> undefined | {rabbit_framing:amqp_field_type(), any()}

tcp_name/3

tcp_name(Prefix::atom(), IPAddress::inet:ip_address(), Port::rabbit_net:ip_port()) -> atom()

throw_on_error/2

throw_on_error(E::atom(), Thunk::thunk(rabbit_types:error(any()) | {ok, A} | A)) -> A

to_amqp_table/1

to_amqp_table(M) -> any()

type_class/1

type_class(Other::rabbit_framing:amqp_field_type()) -> atom()

unfold/2

unfold(Fun::fun((A) -> {true, B, A} | false), A) -> {[B], A}

upmap/2

upmap(F::fun((A) -> B), L::[A]) -> [B]

utf8_safe/1

utf8_safe(V) -> any()

version/0

version() -> string()

version_compare/2

version_compare(A::string(), B::string()) -> lt | eq | gt

version_compare/3

version_compare(A::rabbit_semver:version_string(), B::rabbit_semver:version_string(), X3::lt | lte | eq | gte | gt) -> boolean()

version_minor_equivalent/2

version_minor_equivalent(A::rabbit_semver:version_string(), B::rabbit_semver:version_string()) -> boolean()

which_applications/0

which_applications() -> [{atom(), string(), string()}]

with_exit_handler/2

with_exit_handler(Handler::thunk(A), Thunk::thunk(A)) -> A

with_user/2

with_user(Username::rabbit_types:username(), Thunk::thunk(A)) -> A


Generated by EDoc