mirror of
https://github.com/processone/ejabberd.git
synced 2024-11-20 16:15:59 +01:00
Use p1_utils
This commit is contained in:
Paweł Chmielowski
parent
568068c79f
commit
0456b78d87
@ -56,7 +56,8 @@ Deps = [{p1_cache_tab, ".*", {git, "git://github.com/processone/cache_tab"}},
|
|||||||
{esip, ".*", {git, "git://github.com/processone/p1_sip"}},
|
{esip, ".*", {git, "git://github.com/processone/p1_sip"}},
|
||||||
{p1_stun, ".*", {git, "git://github.com/processone/stun"}},
|
{p1_stun, ".*", {git, "git://github.com/processone/stun"}},
|
||||||
{p1_yaml, ".*", {git, "git://github.com/processone/p1_yaml"}},
|
{p1_yaml, ".*", {git, "git://github.com/processone/p1_yaml"}},
|
||||||
{xmlrpc, ".*", {git, "git://github.com/rds13/xmlrpc"}}],
|
{xmlrpc, ".*", {git, "git://github.com/rds13/xmlrpc"}},
|
||||||
|
{p1_utils, ".*", {git, "git://github.com/processone/p1_utils"}}],
|
||||||
|
|
||||||
ConfigureCmd = fun(Pkg, Flags) ->
|
ConfigureCmd = fun(Pkg, Flags) ->
|
||||||
{'get-deps',
|
{'get-deps',
|
||||||
|
|||||||
848
src/p1_fsm.erl
848
src/p1_fsm.erl
@ -1,848 +0,0 @@
|
|||||||
%% ``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 via the world wide web 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.
|
|
||||||
%%
|
|
||||||
%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
|
|
||||||
%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
|
|
||||||
%% AB. All Rights Reserved.''
|
|
||||||
%%
|
|
||||||
%% The code has been modified and improved by ProcessOne.
|
|
||||||
%% Copyright 2007-2014, ProcessOne
|
|
||||||
%%
|
|
||||||
%% The change adds the following features:
|
|
||||||
%% - You can send exit(priority_shutdown) to the p1_fsm process to
|
|
||||||
%% terminate immediatetly. If the fsm trap_exit process flag has been
|
|
||||||
%% set to true, the FSM terminate function will called.
|
|
||||||
%% - You can pass the gen_fsm options to control resource usage.
|
|
||||||
%% {max_queue, N} will exit the process with priority_shutdown
|
|
||||||
%% - You can limit the time processing a message (TODO): If the
|
|
||||||
%% message processing does not return in a given period of time, the
|
|
||||||
%% process will be terminated.
|
|
||||||
%% - You might customize the State data before sending it to error_logger
|
|
||||||
%% in case of a crash (just export the function print_state/1)
|
|
||||||
%% $Id$
|
|
||||||
%%
|
|
||||||
-module(p1_fsm).
|
|
||||||
|
|
||||||
%%%-----------------------------------------------------------------
|
|
||||||
%%%
|
|
||||||
%%% This state machine is somewhat more pure than state_lib. It is
|
|
||||||
%%% still based on State dispatching (one function per state), but
|
|
||||||
%%% allows a function handle_event to take care of events in all states.
|
|
||||||
%%% It's not that pure anymore :( We also allow synchronized event sending.
|
|
||||||
%%%
|
|
||||||
%%% If the Parent process terminates the Module:terminate/2
|
|
||||||
%%% function is called.
|
|
||||||
%%%
|
|
||||||
%%% The user module should export:
|
|
||||||
%%%
|
|
||||||
%%% init(Args)
|
|
||||||
%%% ==> {ok, StateName, StateData}
|
|
||||||
%%% {ok, StateName, StateData, Timeout}
|
|
||||||
%%% ignore
|
|
||||||
%%% {stop, Reason}
|
|
||||||
%%%
|
|
||||||
%%% StateName(Msg, StateData)
|
|
||||||
%%%
|
|
||||||
%%% ==> {next_state, NewStateName, NewStateData}
|
|
||||||
%%% {next_state, NewStateName, NewStateData, Timeout}
|
|
||||||
%%% {stop, Reason, NewStateData}
|
|
||||||
%%% Reason = normal | shutdown | Term terminate(State) is called
|
|
||||||
%%%
|
|
||||||
%%% StateName(Msg, From, StateData)
|
|
||||||
%%%
|
|
||||||
%%% ==> {next_state, NewStateName, NewStateData}
|
|
||||||
%%% {next_state, NewStateName, NewStateData, Timeout}
|
|
||||||
%%% {reply, Reply, NewStateName, NewStateData}
|
|
||||||
%%% {reply, Reply, NewStateName, NewStateData, Timeout}
|
|
||||||
%%% {stop, Reason, NewStateData}
|
|
||||||
%%% Reason = normal | shutdown | Term terminate(State) is called
|
|
||||||
%%%
|
|
||||||
%%% handle_event(Msg, StateName, StateData)
|
|
||||||
%%%
|
|
||||||
%%% ==> {next_state, NewStateName, NewStateData}
|
|
||||||
%%% {next_state, NewStateName, NewStateData, Timeout}
|
|
||||||
%%% {stop, Reason, Reply, NewStateData}
|
|
||||||
%%% {stop, Reason, NewStateData}
|
|
||||||
%%% Reason = normal | shutdown | Term terminate(State) is called
|
|
||||||
%%%
|
|
||||||
%%% handle_sync_event(Msg, From, StateName, StateData)
|
|
||||||
%%%
|
|
||||||
%%% ==> {next_state, NewStateName, NewStateData}
|
|
||||||
%%% {next_state, NewStateName, NewStateData, Timeout}
|
|
||||||
%%% {reply, Reply, NewStateName, NewStateData}
|
|
||||||
%%% {reply, Reply, NewStateName, NewStateData, Timeout}
|
|
||||||
%%% {stop, Reason, Reply, NewStateData}
|
|
||||||
%%% {stop, Reason, NewStateData}
|
|
||||||
%%% Reason = normal | shutdown | Term terminate(State) is called
|
|
||||||
%%%
|
|
||||||
%%% handle_info(Info, StateName) (e.g. {'EXIT', P, R}, {nodedown, N}, ...
|
|
||||||
%%%
|
|
||||||
%%% ==> {next_state, NewStateName, NewStateData}
|
|
||||||
%%% {next_state, NewStateName, NewStateData, Timeout}
|
|
||||||
%%% {stop, Reason, NewStateData}
|
|
||||||
%%% Reason = normal | shutdown | Term terminate(State) is called
|
|
||||||
%%%
|
|
||||||
%%% terminate(Reason, StateName, StateData) Let the user module clean up
|
|
||||||
%%% always called when server terminates
|
|
||||||
%%%
|
|
||||||
%%% ==> the return value is ignored
|
|
||||||
%%%
|
|
||||||
%%%
|
|
||||||
%%% The work flow (of the fsm) can be described as follows:
|
|
||||||
%%%
|
|
||||||
%%% User module fsm
|
|
||||||
%%% ----------- -------
|
|
||||||
%%% start -----> start
|
|
||||||
%%% init <----- .
|
|
||||||
%%%
|
|
||||||
%%% loop
|
|
||||||
%%% StateName <----- .
|
|
||||||
%%%
|
|
||||||
%%% handle_event <----- .
|
|
||||||
%%%
|
|
||||||
%%% handle__sunc_event <----- .
|
|
||||||
%%%
|
|
||||||
%%% handle_info <----- .
|
|
||||||
%%%
|
|
||||||
%%% terminate <----- .
|
|
||||||
%%%
|
|
||||||
%%%
|
|
||||||
%%% ---------------------------------------------------
|
|
||||||
|
|
||||||
-export([start/3, start/4,
|
|
||||||
start_link/3, start_link/4,
|
|
||||||
send_event/2, sync_send_event/2, sync_send_event/3,
|
|
||||||
send_all_state_event/2,
|
|
||||||
sync_send_all_state_event/2, sync_send_all_state_event/3,
|
|
||||||
reply/2,
|
|
||||||
start_timer/2,send_event_after/2,cancel_timer/1,
|
|
||||||
enter_loop/4, enter_loop/5, enter_loop/6, wake_hib/7]).
|
|
||||||
|
|
||||||
%% Internal exports
|
|
||||||
-export([init_it/6, print_event/3,
|
|
||||||
system_continue/3,
|
|
||||||
system_terminate/4,
|
|
||||||
system_code_change/4,
|
|
||||||
format_status/2]).
|
|
||||||
|
|
||||||
-import(error_logger , [format/2]).
|
|
||||||
|
|
||||||
%%% Internal gen_fsm state
|
|
||||||
%%% This state is used to defined resource control values:
|
|
||||||
-record(limits, {max_queue :: non_neg_integer()}).
|
|
||||||
|
|
||||||
%%% ---------------------------------------------------
|
|
||||||
%%% Interface functions.
|
|
||||||
%%% ---------------------------------------------------
|
|
||||||
|
|
||||||
-callback init(Args :: term()) ->
|
|
||||||
{ok, StateName :: atom(), StateData :: term()} |
|
|
||||||
{ok, StateName :: atom(), StateData :: term(), timeout() | hibernate} |
|
|
||||||
{stop, Reason :: term()} | ignore.
|
|
||||||
-callback handle_event(Event :: term(), StateName :: atom(),
|
|
||||||
StateData :: term()) ->
|
|
||||||
{next_state, NextStateName :: atom(), NewStateData :: term()} |
|
|
||||||
{next_state, NextStateName :: atom(), NewStateData :: term(),
|
|
||||||
timeout() | hibernate} |
|
|
||||||
{migrate, NewStateData :: term(),
|
|
||||||
{Node :: atom(), M :: atom(), F :: atom(), A :: list()},
|
|
||||||
Timeout :: timeout()} |
|
|
||||||
{stop, Reason :: term(), NewStateData :: term()}.
|
|
||||||
-callback handle_sync_event(Event :: term(), From :: {pid(), Tag :: term()},
|
|
||||||
StateName :: atom(), StateData :: term()) ->
|
|
||||||
{reply, Reply :: term(), NextStateName :: atom(), NewStateData :: term()} |
|
|
||||||
{reply, Reply :: term(), NextStateName :: atom(), NewStateData :: term(),
|
|
||||||
timeout() | hibernate} |
|
|
||||||
{next_state, NextStateName :: atom(), NewStateData :: term()} |
|
|
||||||
{next_state, NextStateName :: atom(), NewStateData :: term(),
|
|
||||||
timeout() | hibernate} |
|
|
||||||
{migrate, NewStateData :: term(),
|
|
||||||
{Node :: atom(), M :: atom(), F :: atom(), A :: list()},
|
|
||||||
Timeout :: timeout()} |
|
|
||||||
{stop, Reason :: term(), Reply :: term(), NewStateData :: term()} |
|
|
||||||
{stop, Reason :: term(), NewStateData :: term()}.
|
|
||||||
-callback handle_info(Info :: term(), StateName :: atom(),
|
|
||||||
StateData :: term()) ->
|
|
||||||
{next_state, NextStateName :: atom(), NewStateData :: term()} |
|
|
||||||
{next_state, NextStateName :: atom(), NewStateData :: term(),
|
|
||||||
timeout() | hibernate} |
|
|
||||||
{migrate, NewStateData :: term(),
|
|
||||||
{Node :: atom(), M :: atom(), F :: atom(), A :: list()},
|
|
||||||
Timeout :: timeout()} |
|
|
||||||
{stop, Reason :: normal | term(), NewStateData :: term()}.
|
|
||||||
-callback terminate(Reason :: normal | shutdown | {shutdown, term()}
|
|
||||||
| term(), StateName :: atom(), StateData :: term()) ->
|
|
||||||
term().
|
|
||||||
-callback code_change(OldVsn :: term() | {down, term()}, StateName :: atom(),
|
|
||||||
StateData :: term(), Extra :: term()) ->
|
|
||||||
{ok, NextStateName :: atom(), NewStateData :: term()}.
|
|
||||||
|
|
||||||
%%% ---------------------------------------------------
|
|
||||||
%%% Starts a generic state machine.
|
|
||||||
%%% start(Mod, Args, Options)
|
|
||||||
%%% start(Name, Mod, Args, Options)
|
|
||||||
%%% start_link(Mod, Args, Options)
|
|
||||||
%%% start_link(Name, Mod, Args, Options) where:
|
|
||||||
%%% Name ::= {local, atom()} | {global, atom()}
|
|
||||||
%%% Mod ::= atom(), callback module implementing the 'real' fsm
|
|
||||||
%%% Args ::= term(), init arguments (to Mod:init/1)
|
|
||||||
%%% Options ::= [{debug, [Flag]}]
|
|
||||||
%%% Flag ::= trace | log | {logfile, File} | statistics | debug
|
|
||||||
%%% (debug == log && statistics)
|
|
||||||
%%% Returns: {ok, Pid} |
|
|
||||||
%%% {error, {already_started, Pid}} |
|
|
||||||
%%% {error, Reason}
|
|
||||||
%%% ---------------------------------------------------
|
|
||||||
start(Mod, Args, Options) ->
|
|
||||||
gen:start(?MODULE, nolink, Mod, Args, Options).
|
|
||||||
|
|
||||||
start(Name, Mod, Args, Options) ->
|
|
||||||
gen:start(?MODULE, nolink, Name, Mod, Args, Options).
|
|
||||||
|
|
||||||
start_link(Mod, Args, Options) ->
|
|
||||||
gen:start(?MODULE, link, Mod, Args, Options).
|
|
||||||
|
|
||||||
start_link(Name, Mod, Args, Options) ->
|
|
||||||
gen:start(?MODULE, link, Name, Mod, Args, Options).
|
|
||||||
|
|
||||||
|
|
||||||
send_event({global, Name}, Event) ->
|
|
||||||
catch global:send(Name, {'$gen_event', Event}),
|
|
||||||
ok;
|
|
||||||
send_event(Name, Event) ->
|
|
||||||
Name ! {'$gen_event', Event},
|
|
||||||
ok.
|
|
||||||
|
|
||||||
sync_send_event(Name, Event) ->
|
|
||||||
case catch gen:call(Name, '$gen_sync_event', Event) of
|
|
||||||
{ok,Res} ->
|
|
||||||
Res;
|
|
||||||
{'EXIT',Reason} ->
|
|
||||||
exit({Reason, {?MODULE, sync_send_event, [Name, Event]}})
|
|
||||||
end.
|
|
||||||
|
|
||||||
sync_send_event(Name, Event, Timeout) ->
|
|
||||||
case catch gen:call(Name, '$gen_sync_event', Event, Timeout) of
|
|
||||||
{ok,Res} ->
|
|
||||||
Res;
|
|
||||||
{'EXIT',Reason} ->
|
|
||||||
exit({Reason, {?MODULE, sync_send_event, [Name, Event, Timeout]}})
|
|
||||||
end.
|
|
||||||
|
|
||||||
send_all_state_event({global, Name}, Event) ->
|
|
||||||
catch global:send(Name, {'$gen_all_state_event', Event}),
|
|
||||||
ok;
|
|
||||||
send_all_state_event(Name, Event) ->
|
|
||||||
Name ! {'$gen_all_state_event', Event},
|
|
||||||
ok.
|
|
||||||
|
|
||||||
sync_send_all_state_event(Name, Event) ->
|
|
||||||
case catch gen:call(Name, '$gen_sync_all_state_event', Event) of
|
|
||||||
{ok,Res} ->
|
|
||||||
Res;
|
|
||||||
{'EXIT',Reason} ->
|
|
||||||
exit({Reason, {?MODULE, sync_send_all_state_event, [Name, Event]}})
|
|
||||||
end.
|
|
||||||
|
|
||||||
sync_send_all_state_event(Name, Event, Timeout) ->
|
|
||||||
case catch gen:call(Name, '$gen_sync_all_state_event', Event, Timeout) of
|
|
||||||
{ok,Res} ->
|
|
||||||
Res;
|
|
||||||
{'EXIT',Reason} ->
|
|
||||||
exit({Reason, {?MODULE, sync_send_all_state_event,
|
|
||||||
[Name, Event, Timeout]}})
|
|
||||||
end.
|
|
||||||
|
|
||||||
%% Designed to be only callable within one of the callbacks
|
|
||||||
%% hence using the self() of this instance of the process.
|
|
||||||
%% This is to ensure that timers don't go astray in global
|
|
||||||
%% e.g. when straddling a failover, or turn up in a restarted
|
|
||||||
%% instance of the process.
|
|
||||||
|
|
||||||
%% Returns Ref, sends event {timeout,Ref,Msg} after Time
|
|
||||||
%% to the (then) current state.
|
|
||||||
start_timer(Time, Msg) ->
|
|
||||||
erlang:start_timer(Time, self(), {'$gen_timer', Msg}).
|
|
||||||
|
|
||||||
%% Returns Ref, sends Event after Time to the (then) current state.
|
|
||||||
send_event_after(Time, Event) ->
|
|
||||||
erlang:start_timer(Time, self(), {'$gen_event', Event}).
|
|
||||||
|
|
||||||
%% Returns the remaing time for the timer if Ref referred to
|
|
||||||
%% an active timer/send_event_after, false otherwise.
|
|
||||||
cancel_timer(Ref) ->
|
|
||||||
case erlang:cancel_timer(Ref) of
|
|
||||||
false ->
|
|
||||||
receive {timeout, Ref, _} -> 0
|
|
||||||
after 0 -> false
|
|
||||||
end;
|
|
||||||
RemainingTime ->
|
|
||||||
RemainingTime
|
|
||||||
end.
|
|
||||||
|
|
||||||
%% enter_loop/4,5,6
|
|
||||||
%% Makes an existing process into a gen_fsm.
|
|
||||||
%% The calling process will enter the gen_fsm receive loop and become a
|
|
||||||
%% gen_fsm process.
|
|
||||||
%% The process *must* have been started using one of the start functions
|
|
||||||
%% in proc_lib, see proc_lib(3).
|
|
||||||
%% The user is responsible for any initialization of the process,
|
|
||||||
%% including registering a name for it.
|
|
||||||
enter_loop(Mod, Options, StateName, StateData) ->
|
|
||||||
enter_loop(Mod, Options, StateName, StateData, self(), infinity).
|
|
||||||
|
|
||||||
enter_loop(Mod, Options, StateName, StateData, ServerName = {_,_}) ->
|
|
||||||
enter_loop(Mod, Options, StateName, StateData, ServerName,infinity);
|
|
||||||
enter_loop(Mod, Options, StateName, StateData, Timeout) ->
|
|
||||||
enter_loop(Mod, Options, StateName, StateData, self(), Timeout).
|
|
||||||
|
|
||||||
enter_loop(Mod, Options, StateName, StateData, ServerName, Timeout) ->
|
|
||||||
Name = get_proc_name(ServerName),
|
|
||||||
Parent = get_parent(),
|
|
||||||
Debug = gen:debug_options(Options),
|
|
||||||
Limits = limit_options(Options),
|
|
||||||
Queue = queue:new(),
|
|
||||||
QueueLen = 0,
|
|
||||||
loop(Parent, Name, StateName, StateData, Mod, Timeout, Debug,
|
|
||||||
Limits, Queue, QueueLen).
|
|
||||||
|
|
||||||
get_proc_name(Pid) when is_pid(Pid) ->
|
|
||||||
Pid;
|
|
||||||
get_proc_name({local, Name}) ->
|
|
||||||
case process_info(self(), registered_name) of
|
|
||||||
{registered_name, Name} ->
|
|
||||||
Name;
|
|
||||||
{registered_name, _Name} ->
|
|
||||||
exit(process_not_registered);
|
|
||||||
[] ->
|
|
||||||
exit(process_not_registered)
|
|
||||||
end;
|
|
||||||
get_proc_name({global, Name}) ->
|
|
||||||
case global:whereis_name(Name) of
|
|
||||||
undefined ->
|
|
||||||
exit(process_not_registered_globally);
|
|
||||||
Pid when Pid==self() ->
|
|
||||||
Name;
|
|
||||||
_Pid ->
|
|
||||||
exit(process_not_registered_globally)
|
|
||||||
end.
|
|
||||||
|
|
||||||
get_parent() ->
|
|
||||||
case get('$ancestors') of
|
|
||||||
[Parent | _] when is_pid(Parent) ->
|
|
||||||
Parent;
|
|
||||||
[Parent | _] when is_atom(Parent) ->
|
|
||||||
name_to_pid(Parent);
|
|
||||||
_ ->
|
|
||||||
exit(process_was_not_started_by_proc_lib)
|
|
||||||
end.
|
|
||||||
|
|
||||||
name_to_pid(Name) ->
|
|
||||||
case whereis(Name) of
|
|
||||||
undefined ->
|
|
||||||
case global:whereis_name(Name) of
|
|
||||||
undefined ->
|
|
||||||
exit(could_not_find_registerd_name);
|
|
||||||
Pid ->
|
|
||||||
Pid
|
|
||||||
end;
|
|
||||||
Pid ->
|
|
||||||
Pid
|
|
||||||
end.
|
|
||||||
|
|
||||||
%%% ---------------------------------------------------
|
|
||||||
%%% Initiate the new process.
|
|
||||||
%%% Register the name using the Rfunc function
|
|
||||||
%%% Calls the Mod:init/Args function.
|
|
||||||
%%% Finally an acknowledge is sent to Parent and the main
|
|
||||||
%%% loop is entered.
|
|
||||||
%%% ---------------------------------------------------
|
|
||||||
init_it(Starter, self, Name, Mod, Args, Options) ->
|
|
||||||
init_it(Starter, self(), Name, Mod, Args, Options);
|
|
||||||
init_it(Starter, Parent, Name0, Mod, Args, Options) ->
|
|
||||||
Name = name(Name0),
|
|
||||||
Debug = gen:debug_options(Options),
|
|
||||||
Limits = limit_options(Options),
|
|
||||||
Queue = queue:new(),
|
|
||||||
QueueLen = 0,
|
|
||||||
case catch Mod:init(Args) of
|
|
||||||
{ok, StateName, StateData} ->
|
|
||||||
proc_lib:init_ack(Starter, {ok, self()}),
|
|
||||||
loop(Parent, Name, StateName, StateData, Mod, infinity, Debug, Limits, Queue, QueueLen);
|
|
||||||
{ok, StateName, StateData, Timeout} ->
|
|
||||||
proc_lib:init_ack(Starter, {ok, self()}),
|
|
||||||
loop(Parent, Name, StateName, StateData, Mod, Timeout, Debug, Limits, Queue, QueueLen);
|
|
||||||
{stop, Reason} ->
|
|
||||||
proc_lib:init_ack(Starter, {error, Reason}),
|
|
||||||
exit(Reason);
|
|
||||||
ignore ->
|
|
||||||
proc_lib:init_ack(Starter, ignore),
|
|
||||||
exit(normal);
|
|
||||||
{'EXIT', Reason} ->
|
|
||||||
proc_lib:init_ack(Starter, {error, Reason}),
|
|
||||||
exit(Reason);
|
|
||||||
Else ->
|
|
||||||
Error = {bad_return_value, Else},
|
|
||||||
proc_lib:init_ack(Starter, {error, Error}),
|
|
||||||
exit(Error)
|
|
||||||
end.
|
|
||||||
|
|
||||||
name({local,Name}) -> Name;
|
|
||||||
name({global,Name}) -> Name;
|
|
||||||
name(Pid) when is_pid(Pid) -> Pid.
|
|
||||||
|
|
||||||
%%-----------------------------------------------------------------
|
|
||||||
%% The MAIN loop
|
|
||||||
%%-----------------------------------------------------------------
|
|
||||||
loop(Parent, Name, StateName, StateData, Mod, hibernate, Debug,
|
|
||||||
Limits, Queue, QueueLen)
|
|
||||||
when QueueLen > 0 ->
|
|
||||||
case queue:out(Queue) of
|
|
||||||
{{value, Msg}, Queue1} ->
|
|
||||||
decode_msg(Msg, Parent, Name, StateName, StateData, Mod, hibernate,
|
|
||||||
Debug, Limits, Queue1, QueueLen - 1, false);
|
|
||||||
{empty, _} ->
|
|
||||||
Reason = internal_queue_error,
|
|
||||||
error_info(Mod, Reason, Name, hibernate, StateName, StateData, Debug),
|
|
||||||
exit(Reason)
|
|
||||||
end;
|
|
||||||
loop(Parent, Name, StateName, StateData, Mod, hibernate, Debug,
|
|
||||||
Limits, _Queue, _QueueLen) ->
|
|
||||||
proc_lib:hibernate(?MODULE,wake_hib,
|
|
||||||
[Parent, Name, StateName, StateData, Mod,
|
|
||||||
Debug, Limits]);
|
|
||||||
%% First we test if we have reach a defined limit ...
|
|
||||||
loop(Parent, Name, StateName, StateData, Mod, Time, Debug,
|
|
||||||
Limits, Queue, QueueLen) ->
|
|
||||||
try
|
|
||||||
message_queue_len(Limits, QueueLen)
|
|
||||||
%% TODO: We can add more limit checking here...
|
|
||||||
catch
|
|
||||||
{process_limit, Limit} ->
|
|
||||||
Reason = {process_limit, Limit},
|
|
||||||
Msg = {'EXIT', Parent, {error, {process_limit, Limit}}},
|
|
||||||
terminate(Reason, Name, Msg, Mod, StateName, StateData, Debug)
|
|
||||||
end,
|
|
||||||
process_message(Parent, Name, StateName, StateData,
|
|
||||||
Mod, Time, Debug, Limits, Queue, QueueLen).
|
|
||||||
%% ... then we can process a new message:
|
|
||||||
process_message(Parent, Name, StateName, StateData, Mod, Time, Debug,
|
|
||||||
Limits, Queue, QueueLen) ->
|
|
||||||
{Msg, Queue1, QueueLen1} = collect_messages(Queue, QueueLen, Time),
|
|
||||||
decode_msg(Msg,Parent, Name, StateName, StateData, Mod, Time,
|
|
||||||
Debug, Limits, Queue1, QueueLen1, false).
|
|
||||||
|
|
||||||
collect_messages(Queue, QueueLen, Time) ->
|
|
||||||
receive
|
|
||||||
Input ->
|
|
||||||
case Input of
|
|
||||||
{'EXIT', _Parent, priority_shutdown} ->
|
|
||||||
{Input, Queue, QueueLen};
|
|
||||||
_ ->
|
|
||||||
collect_messages(
|
|
||||||
queue:in(Input, Queue), QueueLen + 1, Time)
|
|
||||||
end
|
|
||||||
after 0 ->
|
|
||||||
case queue:out(Queue) of
|
|
||||||
{{value, Msg}, Queue1} ->
|
|
||||||
{Msg, Queue1, QueueLen - 1};
|
|
||||||
{empty, _} ->
|
|
||||||
receive
|
|
||||||
Input ->
|
|
||||||
{Input, Queue, QueueLen}
|
|
||||||
after Time ->
|
|
||||||
{{'$gen_event', timeout}, Queue, QueueLen}
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end.
|
|
||||||
|
|
||||||
|
|
||||||
wake_hib(Parent, Name, StateName, StateData, Mod, Debug,
|
|
||||||
Limits) ->
|
|
||||||
Msg = receive
|
|
||||||
Input ->
|
|
||||||
Input
|
|
||||||
end,
|
|
||||||
Queue = queue:new(),
|
|
||||||
QueueLen = 0,
|
|
||||||
decode_msg(Msg, Parent, Name, StateName, StateData, Mod, hibernate,
|
|
||||||
Debug, Limits, Queue, QueueLen, true).
|
|
||||||
|
|
||||||
decode_msg(Msg,Parent, Name, StateName, StateData, Mod, Time, Debug,
|
|
||||||
Limits, Queue, QueueLen, Hib) ->
|
|
||||||
put('$internal_queue_len', QueueLen),
|
|
||||||
case Msg of
|
|
||||||
{system, From, Req} ->
|
|
||||||
sys:handle_system_msg(Req, From, Parent, ?MODULE, Debug,
|
|
||||||
[Name, StateName, StateData,
|
|
||||||
Mod, Time, Limits, Queue, QueueLen], Hib);
|
|
||||||
{'EXIT', Parent, Reason} ->
|
|
||||||
terminate(Reason, Name, Msg, Mod, StateName, StateData, Debug);
|
|
||||||
_Msg when Debug == [] ->
|
|
||||||
handle_msg(Msg, Parent, Name, StateName, StateData,
|
|
||||||
Mod, Time, Limits, Queue, QueueLen);
|
|
||||||
_Msg ->
|
|
||||||
Debug1 = sys:handle_debug(Debug, fun print_event/3,
|
|
||||||
{Name, StateName}, {in, Msg}),
|
|
||||||
handle_msg(Msg, Parent, Name, StateName, StateData,
|
|
||||||
Mod, Time, Debug1, Limits, Queue, QueueLen)
|
|
||||||
end.
|
|
||||||
|
|
||||||
%%-----------------------------------------------------------------
|
|
||||||
%% Callback functions for system messages handling.
|
|
||||||
%%-----------------------------------------------------------------
|
|
||||||
system_continue(Parent, Debug, [Name, StateName, StateData,
|
|
||||||
Mod, Time, Limits, Queue, QueueLen]) ->
|
|
||||||
loop(Parent, Name, StateName, StateData, Mod, Time, Debug,
|
|
||||||
Limits, Queue, QueueLen).
|
|
||||||
|
|
||||||
-spec system_terminate(term(), _, _, [term(),...]) -> no_return().
|
|
||||||
|
|
||||||
system_terminate(Reason, _Parent, Debug,
|
|
||||||
[Name, StateName, StateData, Mod, _Time, _Limits]) ->
|
|
||||||
terminate(Reason, Name, [], Mod, StateName, StateData, Debug).
|
|
||||||
|
|
||||||
system_code_change([Name, StateName, StateData, Mod, Time,
|
|
||||||
Limits, Queue, QueueLen],
|
|
||||||
_Module, OldVsn, Extra) ->
|
|
||||||
case catch Mod:code_change(OldVsn, StateName, StateData, Extra) of
|
|
||||||
{ok, NewStateName, NewStateData} ->
|
|
||||||
{ok, [Name, NewStateName, NewStateData, Mod, Time,
|
|
||||||
Limits, Queue, QueueLen]};
|
|
||||||
Else -> Else
|
|
||||||
end.
|
|
||||||
|
|
||||||
%%-----------------------------------------------------------------
|
|
||||||
%% Format debug messages. Print them as the call-back module sees
|
|
||||||
%% them, not as the real erlang messages. Use trace for that.
|
|
||||||
%%-----------------------------------------------------------------
|
|
||||||
print_event(Dev, {in, Msg}, {Name, StateName}) ->
|
|
||||||
case Msg of
|
|
||||||
{'$gen_event', Event} ->
|
|
||||||
io:format(Dev, "*DBG* ~p got event ~p in state ~w~n",
|
|
||||||
[Name, Event, StateName]);
|
|
||||||
{'$gen_all_state_event', Event} ->
|
|
||||||
io:format(Dev,
|
|
||||||
"*DBG* ~p got all_state_event ~p in state ~w~n",
|
|
||||||
[Name, Event, StateName]);
|
|
||||||
{timeout, Ref, {'$gen_timer', Message}} ->
|
|
||||||
io:format(Dev,
|
|
||||||
"*DBG* ~p got timer ~p in state ~w~n",
|
|
||||||
[Name, {timeout, Ref, Message}, StateName]);
|
|
||||||
{timeout, _Ref, {'$gen_event', Event}} ->
|
|
||||||
io:format(Dev,
|
|
||||||
"*DBG* ~p got timer ~p in state ~w~n",
|
|
||||||
[Name, Event, StateName]);
|
|
||||||
_ ->
|
|
||||||
io:format(Dev, "*DBG* ~p got ~p in state ~w~n",
|
|
||||||
[Name, Msg, StateName])
|
|
||||||
end;
|
|
||||||
print_event(Dev, {out, Msg, To, StateName}, Name) ->
|
|
||||||
io:format(Dev, "*DBG* ~p sent ~p to ~w~n"
|
|
||||||
" and switched to state ~w~n",
|
|
||||||
[Name, Msg, To, StateName]);
|
|
||||||
print_event(Dev, return, {Name, StateName}) ->
|
|
||||||
io:format(Dev, "*DBG* ~p switched to state ~w~n",
|
|
||||||
[Name, StateName]).
|
|
||||||
|
|
||||||
relay_messages(MRef, TRef, Clone, Queue) ->
|
|
||||||
lists:foreach(
|
|
||||||
fun(Msg) -> Clone ! Msg end,
|
|
||||||
queue:to_list(Queue)),
|
|
||||||
relay_messages(MRef, TRef, Clone).
|
|
||||||
|
|
||||||
relay_messages(MRef, TRef, Clone) ->
|
|
||||||
receive
|
|
||||||
{'DOWN', MRef, process, Clone, Reason} ->
|
|
||||||
Reason;
|
|
||||||
{'EXIT', _Parent, _Reason} ->
|
|
||||||
{migrated, Clone};
|
|
||||||
{timeout, TRef, timeout} ->
|
|
||||||
{migrated, Clone};
|
|
||||||
Msg ->
|
|
||||||
Clone ! Msg,
|
|
||||||
relay_messages(MRef, TRef, Clone)
|
|
||||||
end.
|
|
||||||
|
|
||||||
handle_msg(Msg, Parent, Name, StateName, StateData, Mod, _Time,
|
|
||||||
Limits, Queue, QueueLen) -> %No debug here
|
|
||||||
From = from(Msg),
|
|
||||||
case catch dispatch(Msg, Mod, StateName, StateData) of
|
|
||||||
{next_state, NStateName, NStateData} ->
|
|
||||||
loop(Parent, Name, NStateName, NStateData,
|
|
||||||
Mod, infinity, [], Limits, Queue, QueueLen);
|
|
||||||
{next_state, NStateName, NStateData, Time1} ->
|
|
||||||
loop(Parent, Name, NStateName, NStateData, Mod, Time1, [],
|
|
||||||
Limits, Queue, QueueLen);
|
|
||||||
{reply, Reply, NStateName, NStateData} when From =/= undefined ->
|
|
||||||
reply(From, Reply),
|
|
||||||
loop(Parent, Name, NStateName, NStateData,
|
|
||||||
Mod, infinity, [], Limits, Queue, QueueLen);
|
|
||||||
{reply, Reply, NStateName, NStateData, Time1} when From =/= undefined ->
|
|
||||||
reply(From, Reply),
|
|
||||||
loop(Parent, Name, NStateName, NStateData, Mod, Time1, [],
|
|
||||||
Limits, Queue, QueueLen);
|
|
||||||
{migrate, NStateData, {Node, M, F, A}, Time1} ->
|
|
||||||
Reason = case catch rpc:call(Node, M, F, A, 5000) of
|
|
||||||
{badrpc, _} = Err ->
|
|
||||||
{migration_error, Err};
|
|
||||||
{'EXIT', _} = Err ->
|
|
||||||
{migration_error, Err};
|
|
||||||
{error, _} = Err ->
|
|
||||||
{migration_error, Err};
|
|
||||||
{ok, Clone} ->
|
|
||||||
process_flag(trap_exit, true),
|
|
||||||
MRef = erlang:monitor(process, Clone),
|
|
||||||
TRef = erlang:start_timer(Time1, self(), timeout),
|
|
||||||
relay_messages(MRef, TRef, Clone, Queue);
|
|
||||||
Reply ->
|
|
||||||
{migration_error, {bad_reply, Reply}}
|
|
||||||
end,
|
|
||||||
terminate(Reason, Name, Msg, Mod, StateName, NStateData, []);
|
|
||||||
{stop, Reason, NStateData} ->
|
|
||||||
terminate(Reason, Name, Msg, Mod, StateName, NStateData, []);
|
|
||||||
{stop, Reason, Reply, NStateData} when From =/= undefined ->
|
|
||||||
{'EXIT', R} = (catch terminate(Reason, Name, Msg, Mod,
|
|
||||||
StateName, NStateData, [])),
|
|
||||||
reply(From, Reply),
|
|
||||||
exit(R);
|
|
||||||
{'EXIT', What} ->
|
|
||||||
terminate(What, Name, Msg, Mod, StateName, StateData, []);
|
|
||||||
Reply ->
|
|
||||||
terminate({bad_return_value, Reply},
|
|
||||||
Name, Msg, Mod, StateName, StateData, [])
|
|
||||||
end.
|
|
||||||
|
|
||||||
handle_msg(Msg, Parent, Name, StateName, StateData,
|
|
||||||
Mod, _Time, Debug, Limits, Queue, QueueLen) ->
|
|
||||||
From = from(Msg),
|
|
||||||
case catch dispatch(Msg, Mod, StateName, StateData) of
|
|
||||||
{next_state, NStateName, NStateData} ->
|
|
||||||
Debug1 = sys:handle_debug(Debug, fun print_event/3,
|
|
||||||
{Name, NStateName}, return),
|
|
||||||
loop(Parent, Name, NStateName, NStateData,
|
|
||||||
Mod, infinity, Debug1, Limits, Queue, QueueLen);
|
|
||||||
{next_state, NStateName, NStateData, Time1} ->
|
|
||||||
Debug1 = sys:handle_debug(Debug, fun print_event/3,
|
|
||||||
{Name, NStateName}, return),
|
|
||||||
loop(Parent, Name, NStateName, NStateData,
|
|
||||||
Mod, Time1, Debug1, Limits, Queue, QueueLen);
|
|
||||||
{reply, Reply, NStateName, NStateData} when From =/= undefined ->
|
|
||||||
Debug1 = reply(Name, From, Reply, Debug, NStateName),
|
|
||||||
loop(Parent, Name, NStateName, NStateData,
|
|
||||||
Mod, infinity, Debug1, Limits, Queue, QueueLen);
|
|
||||||
{reply, Reply, NStateName, NStateData, Time1} when From =/= undefined ->
|
|
||||||
Debug1 = reply(Name, From, Reply, Debug, NStateName),
|
|
||||||
loop(Parent, Name, NStateName, NStateData,
|
|
||||||
Mod, Time1, Debug1, Limits, Queue, QueueLen);
|
|
||||||
{migrate, NStateData, {Node, M, F, A}, Time1} ->
|
|
||||||
Reason = case catch rpc:call(Node, M, F, A, Time1) of
|
|
||||||
{badrpc, R} ->
|
|
||||||
{migration_error, R};
|
|
||||||
{'EXIT', R} ->
|
|
||||||
{migration_error, R};
|
|
||||||
{error, R} ->
|
|
||||||
{migration_error, R};
|
|
||||||
{ok, Clone} ->
|
|
||||||
process_flag(trap_exit, true),
|
|
||||||
MRef = erlang:monitor(process, Clone),
|
|
||||||
TRef = erlang:start_timer(Time1, self(), timeout),
|
|
||||||
relay_messages(MRef, TRef, Clone, Queue);
|
|
||||||
Reply ->
|
|
||||||
{migration_error, {bad_reply, Reply}}
|
|
||||||
end,
|
|
||||||
terminate(Reason, Name, Msg, Mod, StateName, NStateData, Debug);
|
|
||||||
{stop, Reason, NStateData} ->
|
|
||||||
terminate(Reason, Name, Msg, Mod, StateName, NStateData, Debug);
|
|
||||||
{stop, Reason, Reply, NStateData} when From =/= undefined ->
|
|
||||||
{'EXIT', R} = (catch terminate(Reason, Name, Msg, Mod,
|
|
||||||
StateName, NStateData, Debug)),
|
|
||||||
reply(Name, From, Reply, Debug, StateName),
|
|
||||||
exit(R);
|
|
||||||
{'EXIT', What} ->
|
|
||||||
terminate(What, Name, Msg, Mod, StateName, StateData, Debug);
|
|
||||||
Reply ->
|
|
||||||
terminate({bad_return_value, Reply},
|
|
||||||
Name, Msg, Mod, StateName, StateData, Debug)
|
|
||||||
end.
|
|
||||||
|
|
||||||
dispatch({'$gen_event', Event}, Mod, StateName, StateData) ->
|
|
||||||
Mod:StateName(Event, StateData);
|
|
||||||
dispatch({'$gen_all_state_event', Event}, Mod, StateName, StateData) ->
|
|
||||||
Mod:handle_event(Event, StateName, StateData);
|
|
||||||
dispatch({'$gen_sync_event', From, Event}, Mod, StateName, StateData) ->
|
|
||||||
Mod:StateName(Event, From, StateData);
|
|
||||||
dispatch({'$gen_sync_all_state_event', From, Event},
|
|
||||||
Mod, StateName, StateData) ->
|
|
||||||
Mod:handle_sync_event(Event, From, StateName, StateData);
|
|
||||||
dispatch({timeout, Ref, {'$gen_timer', Msg}}, Mod, StateName, StateData) ->
|
|
||||||
Mod:StateName({timeout, Ref, Msg}, StateData);
|
|
||||||
dispatch({timeout, _Ref, {'$gen_event', Event}}, Mod, StateName, StateData) ->
|
|
||||||
Mod:StateName(Event, StateData);
|
|
||||||
dispatch(Info, Mod, StateName, StateData) ->
|
|
||||||
Mod:handle_info(Info, StateName, StateData).
|
|
||||||
|
|
||||||
from({'$gen_sync_event', From, _Event}) -> From;
|
|
||||||
from({'$gen_sync_all_state_event', From, _Event}) -> From;
|
|
||||||
from(_) -> undefined.
|
|
||||||
|
|
||||||
%% Send a reply to the client.
|
|
||||||
reply({To, Tag}, Reply) ->
|
|
||||||
catch To ! {Tag, Reply}.
|
|
||||||
|
|
||||||
reply(Name, {To, Tag}, Reply, Debug, StateName) ->
|
|
||||||
reply({To, Tag}, Reply),
|
|
||||||
sys:handle_debug(Debug, fun print_event/3, Name,
|
|
||||||
{out, Reply, To, StateName}).
|
|
||||||
|
|
||||||
%%% ---------------------------------------------------
|
|
||||||
%%% Terminate the server.
|
|
||||||
%%% ---------------------------------------------------
|
|
||||||
|
|
||||||
-spec terminate(term(), _, _, atom(), _, _, _) -> no_return().
|
|
||||||
|
|
||||||
terminate(Reason, Name, Msg, Mod, StateName, StateData, Debug) ->
|
|
||||||
case catch Mod:terminate(Reason, StateName, StateData) of
|
|
||||||
{'EXIT', R} ->
|
|
||||||
error_info(Mod, R, Name, Msg, StateName, StateData, Debug),
|
|
||||||
exit(R);
|
|
||||||
_ ->
|
|
||||||
case Reason of
|
|
||||||
normal ->
|
|
||||||
exit(normal);
|
|
||||||
shutdown ->
|
|
||||||
exit(shutdown);
|
|
||||||
priority_shutdown ->
|
|
||||||
%% Priority shutdown should be considered as
|
|
||||||
%% shutdown by SASL
|
|
||||||
exit(shutdown);
|
|
||||||
{process_limit, _Limit} ->
|
|
||||||
exit(Reason);
|
|
||||||
{migrated, _Clone} ->
|
|
||||||
exit(normal);
|
|
||||||
_ ->
|
|
||||||
error_info(Mod, Reason, Name, Msg, StateName, StateData, Debug),
|
|
||||||
exit(Reason)
|
|
||||||
end
|
|
||||||
end.
|
|
||||||
|
|
||||||
error_info(Mod, Reason, Name, Msg, StateName, StateData, Debug) ->
|
|
||||||
Reason1 =
|
|
||||||
case Reason of
|
|
||||||
{undef,[{M,F,A}|MFAs]} ->
|
|
||||||
case code:is_loaded(M) of
|
|
||||||
false ->
|
|
||||||
{'module could not be loaded',[{M,F,A}|MFAs]};
|
|
||||||
_ ->
|
|
||||||
case erlang:function_exported(M, F, length(A)) of
|
|
||||||
true ->
|
|
||||||
Reason;
|
|
||||||
false ->
|
|
||||||
{'function not exported',[{M,F,A}|MFAs]}
|
|
||||||
end
|
|
||||||
end;
|
|
||||||
_ ->
|
|
||||||
Reason
|
|
||||||
end,
|
|
||||||
StateToPrint = case erlang:function_exported(Mod, print_state, 1) of
|
|
||||||
true -> (catch Mod:print_state(StateData));
|
|
||||||
false -> StateData
|
|
||||||
end,
|
|
||||||
Str = "** State machine ~p terminating \n" ++
|
|
||||||
get_msg_str(Msg) ++
|
|
||||||
"** When State == ~p~n"
|
|
||||||
"** Data == ~p~n"
|
|
||||||
"** Reason for termination = ~n** ~p~n",
|
|
||||||
format(Str, [Name, get_msg(Msg), StateName, StateToPrint, Reason1]),
|
|
||||||
sys:print_log(Debug),
|
|
||||||
ok.
|
|
||||||
|
|
||||||
get_msg_str({'$gen_event', _Event}) ->
|
|
||||||
"** Last event in was ~p~n";
|
|
||||||
get_msg_str({'$gen_sync_event', _Event}) ->
|
|
||||||
"** Last sync event in was ~p~n";
|
|
||||||
get_msg_str({'$gen_all_state_event', _Event}) ->
|
|
||||||
"** Last event in was ~p (for all states)~n";
|
|
||||||
get_msg_str({'$gen_sync_all_state_event', _Event}) ->
|
|
||||||
"** Last sync event in was ~p (for all states)~n";
|
|
||||||
get_msg_str({timeout, _Ref, {'$gen_timer', _Msg}}) ->
|
|
||||||
"** Last timer event in was ~p~n";
|
|
||||||
get_msg_str({timeout, _Ref, {'$gen_event', _Msg}}) ->
|
|
||||||
"** Last timer event in was ~p~n";
|
|
||||||
get_msg_str(_Msg) ->
|
|
||||||
"** Last message in was ~p~n".
|
|
||||||
|
|
||||||
get_msg({'$gen_event', Event}) -> Event;
|
|
||||||
get_msg({'$gen_sync_event', Event}) -> Event;
|
|
||||||
get_msg({'$gen_all_state_event', Event}) -> Event;
|
|
||||||
get_msg({'$gen_sync_all_state_event', Event}) -> Event;
|
|
||||||
get_msg({timeout, Ref, {'$gen_timer', Msg}}) -> {timeout, Ref, Msg};
|
|
||||||
get_msg({timeout, _Ref, {'$gen_event', Event}}) -> Event;
|
|
||||||
get_msg(Msg) -> Msg.
|
|
||||||
|
|
||||||
%%-----------------------------------------------------------------
|
|
||||||
%% Status information
|
|
||||||
%%-----------------------------------------------------------------
|
|
||||||
format_status(Opt, StatusData) ->
|
|
||||||
[PDict, SysState, Parent, Debug, [Name, StateName, StateData, Mod, _Time, _Limits, _Queue, _QueueLen]] =
|
|
||||||
StatusData,
|
|
||||||
NameTag = if is_pid(Name) ->
|
|
||||||
pid_to_list(Name);
|
|
||||||
is_atom(Name) ->
|
|
||||||
Name
|
|
||||||
end,
|
|
||||||
Header = lists:concat(["Status for state machine ", NameTag]),
|
|
||||||
Log = sys:get_debug(log, Debug, []),
|
|
||||||
Specfic =
|
|
||||||
case erlang:function_exported(Mod, format_status, 2) of
|
|
||||||
true ->
|
|
||||||
case catch Mod:format_status(Opt,[PDict,StateData]) of
|
|
||||||
{'EXIT', _} -> [{data, [{"StateData", StateData}]}];
|
|
||||||
Else -> Else
|
|
||||||
end;
|
|
||||||
_ ->
|
|
||||||
[{data, [{"StateData", StateData}]}]
|
|
||||||
end,
|
|
||||||
[{header, Header},
|
|
||||||
{data, [{"Status", SysState},
|
|
||||||
{"Parent", Parent},
|
|
||||||
{"Logged events", Log},
|
|
||||||
{"StateName", StateName}]} |
|
|
||||||
Specfic].
|
|
||||||
|
|
||||||
%%-----------------------------------------------------------------
|
|
||||||
%% Resources limit management
|
|
||||||
%%-----------------------------------------------------------------
|
|
||||||
%% Extract know limit options
|
|
||||||
limit_options(Options) ->
|
|
||||||
limit_options(Options, #limits{}).
|
|
||||||
limit_options([], Limits) ->
|
|
||||||
Limits;
|
|
||||||
%% Maximum number of messages allowed in the process message queue
|
|
||||||
limit_options([{max_queue,N}|Options], Limits)
|
|
||||||
when is_integer(N) ->
|
|
||||||
NewLimits = Limits#limits{max_queue=N},
|
|
||||||
limit_options(Options, NewLimits);
|
|
||||||
limit_options([_|Options], Limits) ->
|
|
||||||
limit_options(Options, Limits).
|
|
||||||
|
|
||||||
%% Throw max_queue if we have reach the max queue size
|
|
||||||
%% Returns ok otherwise
|
|
||||||
message_queue_len(#limits{max_queue = undefined}, _QueueLen) ->
|
|
||||||
ok;
|
|
||||||
message_queue_len(#limits{max_queue = MaxQueue}, QueueLen) ->
|
|
||||||
Pid = self(),
|
|
||||||
case process_info(Pid, message_queue_len) of
|
|
||||||
{message_queue_len, N} when N + QueueLen > MaxQueue ->
|
|
||||||
throw({process_limit, {max_queue, N + QueueLen}});
|
|
||||||
_ ->
|
|
||||||
ok
|
|
||||||
end.
|
|
||||||
@ -1,327 +0,0 @@
|
|||||||
%%%-------------------------------------------------------------------
|
|
||||||
%%% File : p1_prof.erl
|
|
||||||
%%% Author : Evgeniy Khramtsov <ekhramtsov@process-one.net>
|
|
||||||
%%% Description : Handy wrapper around eprof and fprof
|
|
||||||
%%%
|
|
||||||
%%% Created : 23 Jan 2010 by Evgeniy Khramtsov <ekhramtsov@process-one.net>
|
|
||||||
%%%
|
|
||||||
%%%
|
|
||||||
%%% ejabberd, Copyright (C) 2002-2014 ProcessOne
|
|
||||||
%%%
|
|
||||||
%%% This program is free software; you can redistribute it and/or
|
|
||||||
%%% modify it under the terms of the GNU General Public License as
|
|
||||||
%%% published by the Free Software Foundation; either version 2 of the
|
|
||||||
%%% License, or (at your option) any later version.
|
|
||||||
%%%
|
|
||||||
%%% This program is distributed in the hope that it will be useful,
|
|
||||||
%%% but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
%%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
||||||
%%% General Public License for more details.
|
|
||||||
%%%
|
|
||||||
%%% You should have received a copy of the GNU General Public License along
|
|
||||||
%%% with this program; if not, write to the Free Software Foundation, Inc.,
|
|
||||||
%%% 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
||||||
%%%
|
|
||||||
%%%-------------------------------------------------------------------
|
|
||||||
-module(p1_prof).
|
|
||||||
|
|
||||||
%% API
|
|
||||||
-export([eprof_start/0, eprof_stop/0,
|
|
||||||
fprof_start/0, fprof_start/1,
|
|
||||||
fprof_stop/0, fprof_analyze/0,
|
|
||||||
queue/0, queue/1, memory/0, memory/1,
|
|
||||||
reds/0, reds/1, trace/1, help/0,
|
|
||||||
q/0, m/0, r/0, q/1, m/1, r/1]).
|
|
||||||
|
|
||||||
-define(TRACE_FILE, "/tmp/fprof.trace").
|
|
||||||
-define(ANALYSIS_FILE, "/tmp/fprof.analysis").
|
|
||||||
|
|
||||||
%%====================================================================
|
|
||||||
%% API
|
|
||||||
%%====================================================================
|
|
||||||
eprof_start() ->
|
|
||||||
eprof:start(),
|
|
||||||
case get_procs() of
|
|
||||||
[] ->
|
|
||||||
{error, no_procs_found};
|
|
||||||
Procs ->
|
|
||||||
eprof:start_profiling(Procs)
|
|
||||||
end.
|
|
||||||
|
|
||||||
fprof_start() ->
|
|
||||||
fprof_start(0).
|
|
||||||
|
|
||||||
fprof_start(Duration) ->
|
|
||||||
case get_procs() of
|
|
||||||
[] ->
|
|
||||||
{error, no_procs_found};
|
|
||||||
Procs ->
|
|
||||||
case fprof:trace([start, {procs, Procs}, {file, ?TRACE_FILE}]) of
|
|
||||||
ok ->
|
|
||||||
io:format("Profiling started, writing trace data to ~s~n",
|
|
||||||
[?TRACE_FILE]),
|
|
||||||
if Duration > 0 ->
|
|
||||||
timer:sleep(Duration*1000),
|
|
||||||
fprof:trace([stop]),
|
|
||||||
fprof:stop();
|
|
||||||
true->
|
|
||||||
ok
|
|
||||||
end;
|
|
||||||
Err ->
|
|
||||||
io:format("Couldn't start profiling: ~p~n", [Err]),
|
|
||||||
Err
|
|
||||||
end
|
|
||||||
end.
|
|
||||||
|
|
||||||
fprof_stop() ->
|
|
||||||
fprof:trace([stop]),
|
|
||||||
case fprof:profile([{file, ?TRACE_FILE}]) of
|
|
||||||
ok ->
|
|
||||||
case fprof:analyse([totals, no_details, {sort, own},
|
|
||||||
no_callers, {dest, ?ANALYSIS_FILE}]) of
|
|
||||||
ok ->
|
|
||||||
fprof:stop(),
|
|
||||||
format_fprof_analyze();
|
|
||||||
Err ->
|
|
||||||
io:format("Couldn't analyze: ~p~n", [Err]),
|
|
||||||
Err
|
|
||||||
end;
|
|
||||||
Err ->
|
|
||||||
io:format("Couldn't compile a trace into profile data: ~p~n",
|
|
||||||
[Err]),
|
|
||||||
Err
|
|
||||||
end.
|
|
||||||
|
|
||||||
fprof_analyze() ->
|
|
||||||
fprof_stop().
|
|
||||||
|
|
||||||
eprof_stop() ->
|
|
||||||
eprof:stop_profiling(),
|
|
||||||
case erlang:function_exported(eprof, analyse, 0) of
|
|
||||||
true ->
|
|
||||||
apply(eprof, analyse, []);
|
|
||||||
false ->
|
|
||||||
eprof:analyze()
|
|
||||||
end.
|
|
||||||
|
|
||||||
help() ->
|
|
||||||
M = ?MODULE,
|
|
||||||
io:format("Brief help:~n"
|
|
||||||
"~p:queue(N) - show top N pids sorted by queue length~n"
|
|
||||||
"~p:queue() - shorthand for ~p:queue(10)~n"
|
|
||||||
"~p:memory(N) - show top N pids sorted by memory usage~n"
|
|
||||||
"~p:memory() - shorthand for ~p:memory(10)~n"
|
|
||||||
"~p:reds(N) - show top N pids sorted by reductions~n"
|
|
||||||
"~p:reds() - shorthand for ~p:reds(10)~n"
|
|
||||||
"~p:q(N)|~p:q() - same as ~p:queue(N)|~p:queue()~n"
|
|
||||||
"~p:m(N)|~p:m() - same as ~p:memory(N)|~p:memory()~n"
|
|
||||||
"~p:r(N)|~p:r() - same as ~p:reds(N)|~p:reds()~n"
|
|
||||||
"~p:trace(Pid) - trace Pid; to stop tracing close "
|
|
||||||
"Erlang shell with Ctrl+C~n"
|
|
||||||
"~p:eprof_start() - start eprof on all available pids; "
|
|
||||||
"DO NOT use on production system!~n"
|
|
||||||
"~p:eprof_stop() - stop eprof and print result~n"
|
|
||||||
"~p:fprof_start() - start fprof on all available pids; "
|
|
||||||
"DO NOT use on production system!~n"
|
|
||||||
"~p:fprof_stop() - stop eprof and print formatted result~n"
|
|
||||||
"~p:fprof_start(N) - start and run fprof for N seconds; "
|
|
||||||
"use ~p:fprof_analyze() to analyze collected statistics and "
|
|
||||||
"print formatted result; use on production system with CARE~n"
|
|
||||||
"~p:fprof_analyze() - analyze previously collected statistics "
|
|
||||||
"using ~p:fprof_start(N) and print formatted result~n"
|
|
||||||
"~p:help() - print this help~n",
|
|
||||||
lists:duplicate(31, M)).
|
|
||||||
|
|
||||||
q() ->
|
|
||||||
queue().
|
|
||||||
|
|
||||||
q(N) ->
|
|
||||||
queue(N).
|
|
||||||
|
|
||||||
m() ->
|
|
||||||
memory().
|
|
||||||
|
|
||||||
m(N) ->
|
|
||||||
memory(N).
|
|
||||||
|
|
||||||
r() ->
|
|
||||||
reds().
|
|
||||||
|
|
||||||
r(N) ->
|
|
||||||
reds(N).
|
|
||||||
|
|
||||||
queue() ->
|
|
||||||
queue(10).
|
|
||||||
|
|
||||||
memory() ->
|
|
||||||
memory(10).
|
|
||||||
|
|
||||||
reds() ->
|
|
||||||
reds(10).
|
|
||||||
|
|
||||||
queue(N) ->
|
|
||||||
dump(N, lists:reverse(lists:ukeysort(1, all_pids(queue)))).
|
|
||||||
|
|
||||||
memory(N) ->
|
|
||||||
dump(N, lists:reverse(lists:ukeysort(3, all_pids(memory)))).
|
|
||||||
|
|
||||||
reds(N) ->
|
|
||||||
dump(N, lists:reverse(lists:ukeysort(4, all_pids(reductions)))).
|
|
||||||
|
|
||||||
trace(Pid) ->
|
|
||||||
erlang:trace(Pid, true, [send, 'receive']),
|
|
||||||
trace_loop().
|
|
||||||
|
|
||||||
trace_loop() ->
|
|
||||||
receive
|
|
||||||
M ->
|
|
||||||
io:format("~p~n", [M]),
|
|
||||||
trace_loop()
|
|
||||||
end.
|
|
||||||
|
|
||||||
%%====================================================================
|
|
||||||
%% Internal functions
|
|
||||||
%%====================================================================
|
|
||||||
get_procs() ->
|
|
||||||
processes().
|
|
||||||
|
|
||||||
format_fprof_analyze() ->
|
|
||||||
case file:consult(?ANALYSIS_FILE) of
|
|
||||||
{ok, [_, [{totals, _, _, TotalOWN}] | Rest]} ->
|
|
||||||
OWNs = lists:flatmap(
|
|
||||||
fun({MFA, _, _, OWN}) ->
|
|
||||||
Percent = OWN*100/TotalOWN,
|
|
||||||
case round(Percent) of
|
|
||||||
0 ->
|
|
||||||
[];
|
|
||||||
_ ->
|
|
||||||
[{mfa_to_list(MFA), Percent}]
|
|
||||||
end
|
|
||||||
end, Rest),
|
|
||||||
ACCs = collect_accs(Rest),
|
|
||||||
MaxACC = find_max(ACCs),
|
|
||||||
MaxOWN = find_max(OWNs),
|
|
||||||
io:format("=== Sorted by OWN:~n"),
|
|
||||||
lists:foreach(
|
|
||||||
fun({MFA, Per}) ->
|
|
||||||
L = length(MFA),
|
|
||||||
S = lists:duplicate(MaxOWN - L + 2, $ ),
|
|
||||||
io:format("~s~s~.2f%~n", [MFA, S, Per])
|
|
||||||
end, lists:reverse(lists:keysort(2, OWNs))),
|
|
||||||
io:format("~n=== Sorted by ACC:~n"),
|
|
||||||
lists:foreach(
|
|
||||||
fun({MFA, Per}) ->
|
|
||||||
L = length(MFA),
|
|
||||||
S = lists:duplicate(MaxACC - L + 2, $ ),
|
|
||||||
io:format("~s~s~.2f%~n", [MFA, S, Per])
|
|
||||||
end, lists:reverse(lists:keysort(2, ACCs)));
|
|
||||||
Err ->
|
|
||||||
Err
|
|
||||||
end.
|
|
||||||
|
|
||||||
mfa_to_list({M, F, A}) ->
|
|
||||||
atom_to_list(M) ++ ":" ++ atom_to_list(F) ++ "/" ++ integer_to_list(A);
|
|
||||||
mfa_to_list(F) when is_atom(F) ->
|
|
||||||
atom_to_list(F).
|
|
||||||
|
|
||||||
find_max(List) ->
|
|
||||||
find_max(List, 0).
|
|
||||||
|
|
||||||
find_max([{V, _}|Tail], Acc) ->
|
|
||||||
find_max(Tail, lists:max([length(V), Acc]));
|
|
||||||
find_max([], Acc) ->
|
|
||||||
Acc.
|
|
||||||
|
|
||||||
collect_accs(List) ->
|
|
||||||
List1 = lists:filter(
|
|
||||||
fun({MFA, _, _, _}) ->
|
|
||||||
case MFA of
|
|
||||||
{sys, _, _} ->
|
|
||||||
false;
|
|
||||||
suspend ->
|
|
||||||
false;
|
|
||||||
{gen_fsm, _, _} ->
|
|
||||||
false;
|
|
||||||
{p1_fsm, _, _} ->
|
|
||||||
false;
|
|
||||||
{gen, _, _} ->
|
|
||||||
false;
|
|
||||||
{gen_server, _, _} ->
|
|
||||||
false;
|
|
||||||
{proc_lib, _, _} ->
|
|
||||||
false;
|
|
||||||
_ ->
|
|
||||||
true
|
|
||||||
end
|
|
||||||
end, List),
|
|
||||||
TotalACC = lists:sum([A || {_, _, A, _} <- List1]),
|
|
||||||
lists:flatmap(
|
|
||||||
fun({MFA, _, ACC, _}) ->
|
|
||||||
Percent = ACC*100/TotalACC,
|
|
||||||
case round(Percent) of
|
|
||||||
0 ->
|
|
||||||
[];
|
|
||||||
_ ->
|
|
||||||
[{mfa_to_list(MFA), Percent}]
|
|
||||||
end
|
|
||||||
end, List1).
|
|
||||||
|
|
||||||
all_pids(Type) ->
|
|
||||||
lists:foldl(
|
|
||||||
fun(P, Acc) when P == self() ->
|
|
||||||
%% exclude ourself from statistics
|
|
||||||
Acc;
|
|
||||||
(P, Acc) ->
|
|
||||||
case catch process_info(
|
|
||||||
P,
|
|
||||||
[message_queue_len,
|
|
||||||
memory,
|
|
||||||
reductions,
|
|
||||||
dictionary,
|
|
||||||
current_function,
|
|
||||||
registered_name]) of
|
|
||||||
[{_, Len}, {_, Memory}, {_, Reds},
|
|
||||||
{_, Dict}, {_, CurFun}, {_, RegName}] ->
|
|
||||||
IntQLen = case lists:keysearch('$internal_queue_len', 1, Dict) of
|
|
||||||
{value, {_, N}} ->
|
|
||||||
N;
|
|
||||||
_ ->
|
|
||||||
0
|
|
||||||
end,
|
|
||||||
if Type == queue andalso Len == 0 andalso IntQLen == 0 ->
|
|
||||||
Acc;
|
|
||||||
true ->
|
|
||||||
MaxLen = lists:max([Len, IntQLen]),
|
|
||||||
[{MaxLen, Len, Memory, Reds, Dict, CurFun, P, RegName}|Acc]
|
|
||||||
end;
|
|
||||||
_ ->
|
|
||||||
Acc
|
|
||||||
end
|
|
||||||
end, [], processes()).
|
|
||||||
|
|
||||||
dump(N, Rs) ->
|
|
||||||
lists:foreach(
|
|
||||||
fun({_, MsgQLen, Memory, Reds, Dict, CurFun, Pid, RegName}) ->
|
|
||||||
PidStr = pid_to_list(Pid),
|
|
||||||
[_, Maj, Min] = string:tokens(
|
|
||||||
string:substr(
|
|
||||||
PidStr, 2, length(PidStr) - 2), "."),
|
|
||||||
io:format("** pid(0,~s,~s)~n"
|
|
||||||
"** registered name: ~p~n"
|
|
||||||
"** memory: ~p~n"
|
|
||||||
"** reductions: ~p~n"
|
|
||||||
"** message queue len: ~p~n"
|
|
||||||
"** current_function: ~p~n"
|
|
||||||
"** dictionary: ~p~n~n",
|
|
||||||
[Maj, Min, RegName, Memory, Reds, MsgQLen, CurFun, Dict])
|
|
||||||
end, nthhead(N, Rs)).
|
|
||||||
|
|
||||||
nthhead(N, L) ->
|
|
||||||
lists:reverse(nthhead(N, L, [])).
|
|
||||||
|
|
||||||
nthhead(0, _L, Acc) ->
|
|
||||||
Acc;
|
|
||||||
nthhead(N, [H|T], Acc) ->
|
|
||||||
nthhead(N-1, T, [H|Acc]);
|
|
||||||
nthhead(_N, [], Acc) ->
|
|
||||||
Acc.
|
|
||||||
Loading…
Reference in New Issue
Block a user