Use p1_utils

3 files changed, 2 insertions, 1176 deletions

diff --git a/rebar.config.script b/rebar.config.script
index 4a2158066..5fadc7639 100644
--- a/rebar.config.script
+++ b/rebar.config.script
@@ -56,7 +56,8 @@ Deps = [{p1_cache_tab, ".*", {git, "git://github.com/processone/cache_tab"}},
 	{esip, ".*", {git, "git://github.com/processone/p1_sip"}},
 	{p1_stun, ".*", {git, "git://github.com/processone/stun"}},
         {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) ->
                        {'get-deps',
diff --git a/src/p1_fsm.erl b/src/p1_fsm.erl
deleted file mode 100644
index 80f08c609..000000000
--- a/src/p1_fsm.erl
+++ /dev/null
@@ -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.
diff --git a/tools/p1_prof.erl b/tools/p1_prof.erl
deleted file mode 100644
index c085f64fc..000000000
--- a/tools/p1_prof.erl
+++ /dev/null
@@ -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.