%% %% %CopyrightBegin% %% %% Copyright Ericsson AB 2010-2015. All Rights Reserved. %% %% The contents of this file are subject to the Erlang Public License, %% Version 1.1, (the "License"); you may not use this file except in %% compliance with the License. You should have received a copy of the %% Erlang Public License along with this software. If not, it can be %% retrieved online at http://www.erlang.org/. %% %% Software distributed under the License is distributed on an "AS IS" %% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See %% the License for the specific language governing rights and limitations %% under the License. %% %% %CopyrightEnd% %% -module(diameter_lib). -compile({no_auto_import, [now/0]}). -export([info_report/2, error_report/2, warning_report/2, now/0, timestamp/1, now_diff/1, micro_diff/1, micro_diff/2, time/1, seed/0, eval/1, eval_name/1, get_stacktrace/0, ipaddr/1, spawn_opts/2, wait/1, fold_tuple/3, fold_n/3, for_n/2, log/4]). %% --------------------------------------------------------------------------- %% # get_stacktrace/0 %% --------------------------------------------------------------------------- %% Return a stacktrace with a leading, potentially large, argument %% list replaced by an arity. Trace on stacktrace/0 to see the %% original. get_stacktrace() -> stacktrace(erlang:get_stacktrace()). stacktrace([{M,F,A,L} | T]) when is_list(A) -> [{M, F, length(A), L} | T]; stacktrace(L) -> L. %% --------------------------------------------------------------------------- %% # info_report/2 %% --------------------------------------------------------------------------- -spec info_report(Reason :: term(), T :: term()) -> true. info_report(Reason, T) -> report(fun error_logger:info_report/1, Reason, T), true. %% --------------------------------------------------------------------------- %% # error_report/2 %% # warning_report/2 %% --------------------------------------------------------------------------- -spec error_report(Reason :: term(), T :: term()) -> false. error_report(Reason, T) -> report(fun error_logger:error_report/1, Reason, T). -spec warning_report(Reason :: term(), T :: term()) -> false. warning_report(Reason, T) -> report(fun error_logger:warning_report/1, Reason, T). report(Fun, Reason, T) -> Fun(io_lib:format("diameter: ~" ++ fmt(Reason) ++ "~n ~p~n", [Reason, T])), false. fmt(T) -> if is_list(T) -> "s"; true -> "p" end. %% --------------------------------------------------------------------------- %% # now/0 %% --------------------------------------------------------------------------- -type timestamp() :: {non_neg_integer(), 0..999999, 0..999999}. -type now() :: timestamp(). -spec now() -> now(). %% Use monotonic time if it exists, fall back to erlang:now() %% otherwise. now() -> erlang:now(). %% --------------------------------------------------------------------------- %% # timestamp/1 %% --------------------------------------------------------------------------- -spec timestamp(NowT :: now()) -> timestamp(). timestamp({_,_,_} = T) -> %% erlang:now() T. %% --------------------------------------------------------------------------- %% # now_diff/1 %% --------------------------------------------------------------------------- -spec now_diff(NowT :: now()) -> {Hours, Mins, Secs, MicroSecs} when Hours :: non_neg_integer(), Mins :: 0..59, Secs :: 0..59, MicroSecs :: 0..999999. %% Return timer:now_diff(now(), NowT) as an {H, M, S, MicroS} tuple %% instead of as integer microseconds. now_diff(Time) -> time(micro_diff(Time)). %% --------------------------------------------------------------------------- %% # micro_diff/1 %% --------------------------------------------------------------------------- -spec micro_diff(NowT :: now()) -> MicroSecs when MicroSecs :: non_neg_integer(). micro_diff({_,_,_} = T0) -> timer:now_diff(erlang:now(), T0). %% --------------------------------------------------------------------------- %% # micro_diff/2 %% --------------------------------------------------------------------------- -spec micro_diff(T1 :: now(), T0 :: now()) -> MicroSecs when MicroSecs :: non_neg_integer(). micro_diff(T1, T0) -> %% at least one erlang:now() timer:now_diff(T1, T0). %% --------------------------------------------------------------------------- %% # time/1 %% %% Return an elapsed time as an {H, M, S, MicroS} tuple. %% --------------------------------------------------------------------------- -spec time(NowT | Diff) -> {Hours, Mins, Secs, MicroSecs} when NowT :: timestamp(), Diff :: non_neg_integer(), Hours :: non_neg_integer(), Mins :: 0..59, Secs :: 0..59, MicroSecs :: 0..999999. time({_,_,_} = NowT) -> %% time of day %% 24 hours = 24*60*60*1000000 = 86400000000 microsec time(timer:now_diff(NowT, {0,0,0}) rem 86400000000); time(Micro) -> %% elapsed time Seconds = Micro div 1000000, H = Seconds div 3600, M = (Seconds rem 3600) div 60, S = Seconds rem 60, {H, M, S, Micro rem 1000000}. %% --------------------------------------------------------------------------- %% # seed/0 %% --------------------------------------------------------------------------- -spec seed() -> {timestamp(), {integer(), integer(), integer()}}. %% Return an argument for random:seed/1. seed() -> T = now(), {T, T}. %% --------------------------------------------------------------------------- %% # eval/1 %% %% Evaluate a function in various forms. %% --------------------------------------------------------------------------- -type f() :: {module(), atom(), list()} | nonempty_maybe_improper_list(fun(), list()) | fun(). -spec eval(Fun) -> term() when Fun :: f() | {f()} | nonempty_maybe_improper_list(f(), list()). eval({M,F,A}) -> apply(M,F,A); eval([{M,F,A} | X]) -> apply(M, F, X ++ A); eval([[F|X] | A]) -> eval([F | A ++ X]); eval([F|A]) -> apply(F,A); eval({F}) -> eval(F); eval(F) -> F(). %% --------------------------------------------------------------------------- %% eval_name/1 %% --------------------------------------------------------------------------- eval_name({M,F,A}) -> {M, F, length(A)}; eval_name([{M,F,A} | X]) -> {M, F, length(A) + length(X)}; eval_name([[F|A] | X]) -> eval_name([F | X ++ A]); eval_name([F|_]) -> F; eval_name({F}) -> eval_name(F); eval_name(F) -> F. %% --------------------------------------------------------------------------- %% # ipaddr/1 %% %% Parse an IP address. %% --------------------------------------------------------------------------- -spec ipaddr([byte()] | tuple()) -> inet:ip_address() | none(). %% Don't convert lists of integers since a length 8 list like %% [$1,$0,$.,$0,$.,$0,$.,$1] is ambiguous: is it "10.0.0.1" or %% "49:48:46:48:46:48:46:49"? %% %% RFC 2373 defines the format parsed for v6 addresses. %% Be brutal. ipaddr(Addr) -> try ip(Addr) catch error: _ -> erlang:error({invalid_address, erlang:get_stacktrace()}) end. %% Already a tuple: ensure non-negative integers of the right size. ip(T) when size(T) == 4; size(T) == 8 -> Bs = 2*size(T), [] = lists:filter(fun(N) when 0 =< N -> 0 < N bsr Bs end, tuple_to_list(T)), T; %% Or not: convert from '.'/':'-separated decimal/hex. ip(Addr) -> {ok, A} = inet_parse:address(Addr), %% documented in inet(3) A. %% --------------------------------------------------------------------------- %% # spawn_opts/2 %% --------------------------------------------------------------------------- -spec spawn_opts(server|worker, list()) -> list(). spawn_opts(server, Opts) -> opts(75000, Opts); spawn_opts(worker, Opts) -> opts(5000, Opts). opts(HeapSize, Opts) -> [{min_heap_size, HeapSize} | lists:keydelete(min_heap_size, 1, Opts)]. %% --------------------------------------------------------------------------- %% # wait/1 %% --------------------------------------------------------------------------- -spec wait([pid() | reference()]) -> ok. wait(L) -> lists:foreach(fun down/1, L). down(Pid) when is_pid(Pid) -> down(monitor(process, Pid)); down(MRef) when is_reference(MRef) -> receive {'DOWN', MRef, process, _, _} = T -> T end. %% --------------------------------------------------------------------------- %% # fold_tuple/3 %% --------------------------------------------------------------------------- -spec fold_tuple(N, T0, T) -> tuple() when N :: pos_integer(), T0 :: tuple(), T :: tuple() | undefined. %% Replace fields in T0 by those of T starting at index N, unless the %% new value is 'undefined'. %% %% eg. fold_tuple(2, Hdr, #diameter_header{end_to_end_id = 42}) fold_tuple(_, T, undefined) -> T; fold_tuple(N, T0, T1) -> {_, T} = lists:foldl(fun(V, {I,_} = IT) -> {I+1, ft(V, IT)} end, {N, T0}, lists:nthtail(N-1, tuple_to_list(T1))), T. ft(undefined, {_, T}) -> T; ft(Value, {Idx, T}) -> setelement(Idx, T, Value). %% --------------------------------------------------------------------------- %% # fold_n/3 %% --------------------------------------------------------------------------- -spec fold_n(F, Acc0, N) -> term() when F :: fun((non_neg_integer(), term()) -> term()), Acc0 :: term(), N :: non_neg_integer(). fold_n(F, Acc, N) when is_integer(N), 0 < N -> fold_n(F, F(N, Acc), N-1); fold_n(_, Acc, _) -> Acc. %% --------------------------------------------------------------------------- %% # for_n/2 %% --------------------------------------------------------------------------- -spec for_n(F, N) -> non_neg_integer() when F :: fun((non_neg_integer()) -> term()), N :: non_neg_integer(). for_n(F, N) -> fold_n(fun(M,A) -> F(M), A+1 end, 0, N). %% --------------------------------------------------------------------------- %% # log/4 %% %% Called to have something to trace on for happenings of interest. %% --------------------------------------------------------------------------- log(_Slogan, _Mod, _Line, _Details) -> ok.