Module rabbit_misc

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

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

amqp_table(Table) -> any()

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

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

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(Current::any(), New::any(), Name::rabbit_types:r(any()), Key::atom() | binary()) -> ok | rabbit_types:connection_exit()

b64decode_or_throw(B64) -> any()

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

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(X1::tref()) -> ok

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

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

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

const(A) -> thunk(A)

decompose_pid(Pid) -> any()

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

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

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

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

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

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

enable_cover() -> ok_or_error()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

get_channel_operation_timeout() -> non_neg_integer()

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

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

get_parent() -> pid()

get_proc_name() -> rabbit_types:proc_name()

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

hexify(Bin::binary() | atom() | list()) -> binary()

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(R::any()) -> boolean()

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

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

is_regular_file(Name) -> boolean()

• Name = file:filename_all()

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

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

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

module_attributes_from_apps(Name, Apps) -> any()

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

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

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

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

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

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

otp_release() -> string()

otp_system_version() -> string()

parse_bool(V) -> any()

parse_int(I) -> any()

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

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

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

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

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

platform_and_version() -> string()

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

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

polite_pause() -> done

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

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

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

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

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

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

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

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

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

• K = atom()

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

• K = atom()

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)

• K = atom()

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

rabbitmq_related_apps() -> any()

rabbitmq_related_module_attributes(Name) -> any()

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

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

• Filename = file:name_all()
• Binary = binary()
• Reason = file:posix() | badarg | terminated | system_limit

report_cover() -> ok

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

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

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

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

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

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

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(M::rabbit_framing:amqp_table()) -> rabbit_framing:amqp_table()

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

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

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

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

strict_version_minor_equivalent(A, B) -> any()

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

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

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

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

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

to_amqp_table(M) -> any()

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

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

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

utf8_safe(V) -> any()

version() -> string()

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

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

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

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

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

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