The R13B03 release.OTP_R13B03

1 files changed, 426 insertions, 0 deletions

diff --git a/lib/kernel/src/application_master.erl b/lib/kernel/src/application_master.erl
new file mode 100644
index 0000000000..679fefaed9
--- /dev/null
+++ b/lib/kernel/src/application_master.erl
@@ -0,0 +1,426 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1996-2009. 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(application_master).
+
+%% External exports
+-export([start_link/2, start_type/0, stop/1]).
+-export([get_child/1]).
+
+%% Internal exports
+-export([init/4, start_it/4]).
+
+-include("application_master.hrl").
+
+-record(state, {child, appl_data, children = [], procs = 0, gleader}).
+
+%%-----------------------------------------------------------------
+%% Func: start_link/1
+%% Args: ApplData = record(appl_data)
+%% Purpose: Starts an application master for the application.
+%%          Called from application_controller.  (The application is
+%%          also started).
+%% Returns: {ok, Pid} | {error, Reason} (Pid is unregistered)
+%%-----------------------------------------------------------------
+start_link(ApplData, Type) ->
+    Parent = whereis(application_controller),
+    proc_lib:start_link(application_master, init,
+			[Parent, self(), ApplData, Type]).
+
+start_type() ->
+    group_leader() ! {start_type, self()},
+    receive
+	{start_type, Type} ->
+	    Type
+    after 5000 ->
+	    {error, timeout}
+    end.
+
+%%-----------------------------------------------------------------
+%% Func: stop/1
+%% Purpose: Stops the application.  This function makes sure
+%%          that all processes belonging to the applicication is
+%%          stopped (shutdown or killed).  The application master
+%%          is also stopped.
+%% Returns: ok
+%%-----------------------------------------------------------------
+stop(AppMaster) -> call(AppMaster, stop).
+
+%%-----------------------------------------------------------------
+%% Func: get_child/1
+%% Purpose: Get the topmost supervisor of an application.
+%% Returns: {pid(), App}
+%%-----------------------------------------------------------------
+get_child(AppMaster) -> call(AppMaster, get_child).
+    
+call(AppMaster, Req) ->
+    Tag = make_ref(),
+    Ref = erlang:monitor(process, AppMaster),
+    AppMaster ! {Req, Tag, self()},
+    receive 
+	{'DOWN', Ref, process, _, _Info} ->
+	    ok;
+	{Tag, Res} ->
+	    erlang:demonitor(Ref),
+	    receive 
+		{'DOWN', Ref, process, _, _Info} -> 
+		    Res
+	    after 0 ->
+		    Res
+	    end
+    end.
+
+%%%-----------------------------------------------------------------
+%%% The logical and physical process structrure is as follows:
+%%%
+%%%         logical                physical
+%%%
+%%%         --------               --------
+%%%         |AM(GL)|               |AM(GL)|               
+%%%         --------               -------- 
+%%%            |                       |
+%%%         --------               --------
+%%%         |Appl P|               |   X  |
+%%%         --------               --------
+%%%                                    |
+%%%                                --------
+%%%                                |Appl P|
+%%%                                --------
+%%%
+%%% Where AM(GL) == Application Master (Group Leader)
+%%%       Appl P == The application specific root process (child to AM)
+%%%       X      == A special 'invisible' process
+%%% The reason for not using the logical structrure is that
+%%% the application start function is synchronous, and 
+%%% that the AM is GL.  This means that if AM executed the start
+%%% function, and this function uses spawn_request/1
+%%% or io, deadlock would occur.  Therefore, this function is
+%%% executed by the process X.  Also, AM needs three loops;
+%%% init_loop (waiting for the start function to return)
+%%% main_loop
+%%% terminate_loop (waiting for the process to die)
+%%% In each of these loops, io and other requests are handled.
+%%%-----------------------------------------------------------------
+%%% Internal functions
+%%%-----------------------------------------------------------------
+init(Parent, Starter, ApplData, Type) ->
+    link(Parent),
+    process_flag(trap_exit, true),
+    OldGleader = group_leader(),
+    group_leader(self(), self()),
+    %% Insert ourselves as master for the process.  This ensures that
+    %% the processes in the application can use get_env/1 at startup.
+    Name = ApplData#appl_data.name,
+    ets:insert(ac_tab, {{application_master, Name}, self()}),
+    State = #state{appl_data = ApplData, gleader = OldGleader},
+    case start_it(State, Type) of
+	{ok, Pid} ->          % apply(M,F,A) returned ok
+	    set_timer(ApplData#appl_data.maxT),
+	    unlink(Starter),
+	    proc_lib:init_ack(Starter, {ok,self()}),
+	    main_loop(Parent, State#state{child = Pid});
+	{error, Reason} ->    % apply(M,F,A) returned error
+	    exit(Reason);
+	Else ->               % apply(M,F,A) returned erroneous
+	    exit(Else)
+    end.
+
+%%-----------------------------------------------------------------
+%% We want to start the new application synchronously, but we still
+%% want to handle io requests.  So we spawn off a new process that
+%% performs the apply, and we wait for a start ack.
+%%-----------------------------------------------------------------
+start_it(State, Type) ->
+    Tag = make_ref(),
+    Pid = spawn_link(application_master, start_it, [Tag, State, self(), Type]),
+    init_loop(Pid, Tag, State, Type).
+
+
+%%-----------------------------------------------------------------
+%% These are the three different loops executed by the application_
+%% master
+%%-----------------------------------------------------------------
+init_loop(Pid, Tag, State, Type) ->
+    receive
+ 	IoReq when element(1, IoReq) =:= io_request ->
+	    State#state.gleader ! IoReq,
+	    init_loop(Pid, Tag, State, Type);
+	{Tag, Res} ->
+	    Res;
+	{'EXIT', Pid, Reason} ->
+	    {error, Reason};
+	{start_type, From} ->
+	    From ! {start_type, Type},
+	    init_loop(Pid, Tag, State, Type);
+	Other ->
+	    NewState = handle_msg(Other, State),
+	    init_loop(Pid, Tag, NewState, Type)
+    end.
+
+main_loop(Parent, State) ->
+    receive
+	IoReq when element(1, IoReq) =:= io_request ->
+	    State#state.gleader ! IoReq,
+	    main_loop(Parent, State);
+	{'EXIT', Parent, Reason} ->
+	    terminate(Reason, State);
+	{'EXIT', Child, Reason} when State#state.child =:= Child ->
+	    terminate(Reason, State#state{child=undefined});
+	{'EXIT', _, timeout} ->
+	    terminate(normal, State);
+	{'EXIT', Pid, _Reason} ->
+	    Children = lists:delete(Pid, State#state.children),
+	    Procs = State#state.procs - 1,
+	    main_loop(Parent, State#state{children=Children, procs=Procs});
+	{start_type, From} ->
+	    From ! {start_type, local},
+	    main_loop(Parent, State);
+	Other ->
+	    NewState = handle_msg(Other, State),
+	    main_loop(Parent, NewState)
+    end.
+
+terminate_loop(Child, State) ->
+    receive
+ 	IoReq when element(1, IoReq) =:= io_request ->
+	    State#state.gleader ! IoReq,
+	    terminate_loop(Child, State);
+	{'EXIT', Child, _} ->
+	    ok;
+	Other ->
+	    NewState = handle_msg(Other, State),
+	    terminate_loop(Child, NewState)
+    end.
+
+
+%%-----------------------------------------------------------------
+%% The Application Master is linked to *all* processes in the group
+%% (application).  
+%%-----------------------------------------------------------------
+handle_msg({get_child, Tag, From}, State) ->
+    From ! {Tag, get_child_i(State#state.child)},
+    State;
+handle_msg({stop, Tag, From}, State) ->
+    catch terminate(normal, State),
+    From ! {Tag, ok},
+    exit(normal);
+handle_msg(_, State) ->
+    State.
+
+
+terminate(Reason, State) ->
+    terminate_child(State#state.child, State),
+    kill_children(State#state.children),
+    exit(Reason).
+
+
+
+
+%%======================================================================
+%%======================================================================
+%%======================================================================
+%% This is the process X above...
+%%======================================================================
+%%======================================================================
+%%======================================================================
+
+%%======================================================================
+%% Start an application.
+%% If the start_phases is defined in the .app file, the application is
+%% to be started in one or several start phases.
+%% If the Module in the mod-key is set to application_starter then
+%% the generic help module application_starter is used to control
+%% the start.
+%%======================================================================
+
+start_it(Tag, State, From, Type) ->
+    process_flag(trap_exit, true),
+    ApplData = State#state.appl_data,
+    case {ApplData#appl_data.phases, ApplData#appl_data.mod} of
+	{undefined, _} ->
+	    start_it_old(Tag, From, Type, ApplData);
+	{Phases, {application_starter, [M, A]}} ->
+	    start_it_new(Tag, From, Type, M, A, Phases, 
+			 [ApplData#appl_data.name]);
+	{Phases, {M, A}} ->
+	    start_it_new(Tag, From, Type, M, A, Phases, 
+			 [ApplData#appl_data.name]);
+	{OtherP, OtherM} ->
+	    From ! {Tag, {error, {bad_keys, {{mod, OtherM}, 
+					     {start_phases, OtherP}}}}}
+    end.
+
+
+%%%-----------------------------------------------------
+%%% No start phases are defined
+%%%-----------------------------------------------------
+start_it_old(Tag, From, Type, ApplData) ->
+    {M,A} = ApplData#appl_data.mod,
+    case catch M:start(Type, A) of
+	{ok, Pid} ->
+	    link(Pid),
+	    From ! {Tag, {ok, self()}},
+	    loop_it(From, Pid, M, []);
+	{ok, Pid, AppState} ->
+	    link(Pid),
+	    From ! {Tag, {ok, self()}},
+	    loop_it(From, Pid, M, AppState);
+	{'EXIT', normal} ->
+	    From ! {Tag, {error, {{'EXIT',normal},{M,start,[Type,A]}}}};
+	{error, Reason} ->
+	    From ! {Tag, {error, {Reason, {M,start,[Type,A]}}}};
+	Other ->
+	    From ! {Tag, {error, {bad_return,{{M,start,[Type,A]},Other}}}}
+    end.
+
+
+%%%-----------------------------------------------------
+%%% Start phases are defined
+%%%-----------------------------------------------------
+start_it_new(Tag, From, Type, M, A, Phases, Apps) ->
+    case catch start_the_app(Type, M, A, Phases, Apps) of
+	{ok, Pid, AppState} ->
+	    From ! {Tag, {ok, self()}},
+	    loop_it(From, Pid, M, AppState);    
+	Error ->
+	    From ! {Tag, Error}
+    end.
+
+
+%%%=====================================================
+%%% Start the application in the defined phases, 
+%%% but first the supervisors are starter.
+%%%=====================================================
+start_the_app(Type, M, A, Phases, Apps) ->
+    case start_supervisor(Type, M, A) of
+ 	{ok, Pid, AppState} ->
+	    link(Pid),
+	    case application_starter:start(Phases, Type, Apps) of
+		ok ->
+		    {ok, Pid, AppState};
+		Error2 ->
+		    unlink(Pid),
+		    Error2
+	    end;
+	Error ->
+	    Error
+    end.
+
+%%%-------------------------------------------------------------
+%%% Start the supervisors
+%%%-------------------------------------------------------------
+start_supervisor(Type, M, A) ->
+    case catch M:start(Type, A) of
+	{ok, Pid} ->
+	    {ok, Pid, []};
+	{ok, Pid, AppState} ->
+	    {ok, Pid, AppState};
+	{error, Reason} ->
+	    {error, {Reason, {M, start, [Type, A]}}};
+	{'EXIT', normal} ->
+	    {error, {{'EXIT', normal}, {M, start, [Type, A]}}};
+	Other ->
+	    {error, {bad_return, {{M, start, [Type, A]}, Other}}}
+    end.
+
+
+
+
+%%======================================================================
+%%
+%%======================================================================
+
+loop_it(Parent, Child, Mod, AppState) ->
+    receive
+	{Parent, get_child} ->
+	    Parent ! {self(), Child, Mod},
+	    loop_it(Parent, Child, Mod, AppState);
+	{Parent, terminate} ->
+	    NewAppState = prep_stop(Mod, AppState),
+	    exit(Child, shutdown),
+	    receive
+		{'EXIT', Child, _} -> ok
+	    end,
+	    catch Mod:stop(NewAppState),
+	    exit(normal);
+	{'EXIT', Parent, Reason} ->
+	    NewAppState = prep_stop(Mod, AppState),
+	    exit(Child, Reason),
+	    receive
+		{'EXIT', Child, Reason2} ->
+		    exit(Reason2)
+	    end,
+	    catch Mod:stop(NewAppState);
+	{'EXIT', Child, Reason} -> % forward *all* exit reasons (inc. normal)
+	    NewAppState = prep_stop(Mod, AppState),
+	    catch Mod:stop(NewAppState),
+	    exit(Reason);
+	_ ->
+	    loop_it(Parent, Child, Mod, AppState)
+    end.
+
+prep_stop(Mod, AppState) ->
+    case catch Mod:prep_stop(AppState) of
+	{'EXIT', {undef, _}} ->
+	    AppState;
+	{'EXIT', Reason} ->
+	    error_logger:error_report([{?MODULE, shutdown_error},
+				       {Mod, {prep_stop, [AppState]}},
+				       {error_info, Reason}]),
+	    AppState;
+	NewAppState ->
+	    NewAppState
+    end.
+
+get_child_i(Child) ->
+    Child ! {self(), get_child},
+    receive
+	{Child, GrandChild, Mod} -> {GrandChild, Mod}
+    end.
+
+terminate_child_i(Child, State) ->
+    Child ! {self(), terminate},
+    terminate_loop(Child, State).
+
+%% Try to shutdown the child gently
+terminate_child(undefined, _) -> ok;
+terminate_child(Child, State) ->
+    terminate_child_i(Child, State).
+
+kill_children(Children) ->
+    lists:foreach(fun(Pid) -> exit(Pid, kill) end, Children),
+    kill_all_procs().
+
+kill_all_procs() ->
+    kill_all_procs_1(processes(), self(), 0).
+
+kill_all_procs_1([Self|Ps], Self, N) ->
+    kill_all_procs_1(Ps, Self, N);
+kill_all_procs_1([P|Ps], Self, N) ->
+    case process_info(P, group_leader) of
+	{group_leader,Self} ->
+	    exit(P, kill),
+	    kill_all_procs_1(Ps, Self, N+1);
+	_ ->
+	    kill_all_procs_1(Ps, Self, N)
+    end;
+kill_all_procs_1([], _, 0) -> ok;
+kill_all_procs_1([], _, _) -> kill_all_procs().
+
+set_timer(infinity) -> ok;
+set_timer(Time) -> timer:exit_after(Time, timeout).