%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 1997-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(pman_main).
-compile([{nowarn_deprecated_function,{gs,config,2}},
{nowarn_deprecated_function,{gs,read,2}}]).
%% Main process and window
-export([init/2]).
-record(state, {win, % GS top window
frame, % GS top frame
grid, % GS process info grid
size, % int() No. of displayed procs
w, % int() Window width
h, % int() Window height
hide_system=false, % bool() Auto-hide system procs
hide_new=false, % bool() Auto-hide new processes
hide_modules, % ordset() Excluded modules
hide_all=[], % [{node(), bool()}] Hide all
hide_pids=[], % [{node(), Ordset}] Processes
% explicitly to hide, per node
show_pids=[], % [{node(), Ordset}] Processes
% explicitly to show, per node
shown_pids=[], % [{node(), Ordset}] Processes
% actually shown, per node
node, % node() Current node
nodes=[], % [node()] All known nodes
focus=1, % int() Grid line with focus
focus_pid=undefined, % pid() | undefined Proc in focus
noshell, % bool() Noshell mode on
options}). % term() Trace options settings
-include("pman_win.hrl").
-define(REFRESH_TIME,5000).
-define(REQUIRES_FOCUS, % List of menus that should
['Trace Process', % be disabled if no process
'Kill', % is in focus
'Hide Selected Process',
'Module']).
%%--Process init and loop-----------------------------------------------
init(PidCaller, OSModuleExcluded) ->
process_flag(trap_exit, true),
%% Monitor all nodes in a distributed system
case is_alive() of
%% We have a distributed system
true -> net_kernel:monitor_nodes(true);
%% No distribution
false -> ignore
end,
Nodes = [node()|nodes()],
%% Create the main window
%% For some extremely strange reason, the frame must be resized
%% or the grid won't be visible...
GridSize = length(processes()) + 61,
{Window, Grid, Frame, Visible, W, H} =
pman_win:pman_window(GridSize, OSModuleExcluded, Nodes),
gse:resize(Frame, ?WIN_WIDTH, ?WIN_HEIGHT-?MENU_HEIGHT),
Noshell = case pman_shell:find_shell() of
noshell -> true;
_ -> false
end,
State1 = #state{win=Window, frame=Frame, grid=Grid,
size=Visible,
w=W, h=H,
hide_modules=OSModuleExcluded,
node=node(),
noshell=Noshell},
State2 = lists:foldl(fun(Node, State) -> add_node(Node, State) end,
State1,
Nodes),
State3 = refresh(State2),
%% Notify caller that the process appears
%% to have been started.
PidCaller ! {initialization_complete, self()},
%% Initiate a 'catch all' trace pattern so call tracing works
erlang:trace_pattern({'_', '_', '_'}, true, [local]),
%% Read default options file
Options = restore_options(State3),
loop(State3#state{options=Options}).
add_node(Node, State) ->
pman_win:add_menu(node, [Node], "Show"),
State#state{hide_all=nl_update(Node, false, State#state.hide_all),
hide_pids=nl_update(Node, [], State#state.hide_pids),
show_pids=nl_update(Node, [], State#state.show_pids),
shown_pids=nl_update(Node, [], State#state.shown_pids),
nodes=[Node|State#state.nodes]}.
%% Restore saved options from default file
restore_options(State)->
File = options_file(),
case pman_options:read_from_file(File) of
{ok, Options} ->
Options;
{error, ReasonStr, DefOptions} ->
Parent = State#state.win,
Msg = io_lib:format(
"Problems reading default option file~n~s:~n~s",
[File, ReasonStr]),
tool_utils:notify(Parent, Msg),
DefOptions
end.
options_file() ->
{ok, [[Home]]} = init:get_argument(home),
filename:join([Home, ".erlang_tools", "pman.opts"]).
loop(State) ->
receive
{nodeup, Node} ->
case nl_exists(Node, State#state.hide_all) of
true ->
pman_win:add_menu(node, [Node], "Show"),
loop(State#state{nodes=[Node|State#state.nodes]});
false ->
loop(add_node(Node, State))
end;
{nodedown, Node} ->
pman_win:remove_menu([Node]),
Msg = io_lib:format("Node~n~p~ndown.", [Node]),
spawn_link(tool_utils, notify, [State#state.win, Msg]),
%% We remove Node from the list of nodes but not from
%% the other lists of State, in case Node reappears later
Nodes = lists:delete(Node, State#state.nodes),
State2 = State#state{nodes=Nodes},
%% If it was the shown node that went down,
%% change overview to this node
if
Node==State#state.node ->
State3 = execute_cmd({node,node()}, State2, [], []),
loop(State3);
true ->
loop(State2)
end;
%% Ignore EXIT signals from help processes
{'EXIT', _Pid, _Reason} ->
loop(State);
%% GS events
{gs, _Obj, _Event, _Data, _Args} = Cmd ->
case gs_cmd(Cmd, State) of
stop ->
exit(topquit);
State2 ->
loop(State2)
end
after ?REFRESH_TIME ->
State2 = refresh(State),
loop(State2)
end.
%% gs_cmd(Event, State) -> stop | State'
gs_cmd(Event, State) ->
case Event of
%% --- Window manager commands ---
%% Window is moved or resized
{gs, _, configure, _Data, Args} ->
configure(Args, State);
%% Window closed, stop Pman
{gs, _, destroy, _, _} ->
stop;
%% --- Dynamic commands ---
%% Click in any object where the GS Data field is a 2-tuple
{gs, _, click, Data, Args} when is_tuple(Data), size(Data)==2 ->
execute_cmd(Data, State, [], Args);
%% Single click in the grid sets focus to selected process
{gs, _, click, {pidfunc,_,_}, [_,Row|_]} when is_integer(Row) ->
focus(Row, State);
%% Double click in the grid starts tracing of selected process
{gs, _, doubleclick, {pidfunc,_,_}, [_Col,Row| _]} when is_integer(Row) ->
execute_cmd('Trace Process', State, [], []);
%% Click in named GS objects
{gs, Cmd, click, Data, Args} when is_atom(Cmd);
is_atom(element(1, Cmd)) ->
execute_cmd(Cmd, State, Data, Args);
%% --- Keyboard accelerator commands ---
%% Move focus up and down
{gs, _, keypress, [], ['Up',_,0,0]} ->
execute_cmd(focus_previous, State, [], []);
{gs, _, keypress, [], ['Down',_,0,0]} ->
execute_cmd(focus_next, State, [], []);
%% Other keyboard shortcuts
{gs, _, keypress, [], ['Return',_,0,0]} ->
execute_cmd('Trace Process', State, [], []);
{gs, _, keypress, [], [Key,_,0,1]} ->
execute_cmd(shortcut(Key), State, [], []);
%% Ignore all other GS events
_Other ->
State
end.
%% Keyboard shortcuts
%% File menu
shortcut(o) -> 'Default Options';
shortcut(e) -> 'Exit';
shortcut(z) -> 'Exit';
%% View menu
shortcut(i) -> 'Hide All';
shortcut(u) -> 'Hide Modules';
shortcut(d) -> 'Hide Selected Process';
shortcut(m) -> 'Module';
shortcut(r) -> 'Refresh';
%% Trace menu
shortcut(k) -> 'Kill';
shortcut(t) -> 'Trace Process';
shortcut(s) -> 'Trace Shell';
%% Help menu
shortcut(h) -> 'Help';
%% Keyboard command only
shortcut(l) -> 'All Links';
%% Process grid traversal
shortcut(p) -> focus_previous;
shortcut(n) -> focus_next;
shortcut(_) -> dummy.
%% configure([W,H,X,Y|_], State) -> State'
%% Window has been moved or resized
configure([W,H|_], State) ->
if
W==State#state.w, H==State#state.h ->
ignore;
true ->
gse:resize(State#state.frame, W, H-?MENU_HEIGHT),
Grid = State#state.grid,
case abs(W - gs:read(Grid,width) - 6) of
0 ->
ok; %% Avoid refreshing width if possible
_Anything ->
Cols = pman_win:calc_columnwidths(W-6),
gs:config(Grid, Cols)
end,
pman_win:configwin(Grid, W, H)
end,
State.
%% focus(Row, State) -> State'
%% Row = int() Grid row
%% User has selected a row in the grid.
%% Row==1 means header row.
focus(Row, State) ->
Pid = case get_pid_in_focus(Row, State#state.grid) of
{true, {pidfunc,Pid0,_}} ->
pman_win:change_colour(State#state.grid,
State#state.focus, Row),
enable_pid_actions(),
Pid0;
false ->
disable_pid_actions(),
undefined
end,
State#state{focus=Row, focus_pid=Pid}.
%% get_pid_in_focus(Row, Grid) -> {true, Data} | false
%% Data = {pidfunc, Pid, Func}
%% Func = {Mod,Name,Arity} | term()
%% Return the data associated with the process in focus if there is one,
get_pid_in_focus(1, _Grid) ->
false;
get_pid_in_focus(Row, Grid) ->
case gs:read(Grid, {obj_at_row,Row}) of
undefined -> false;
GridLine ->
Data = gs:read(GridLine, data),
{true, Data}
end.
%% execute_cmd(Cmd, State, Data, Args) -> stop | State'
%% Checkbutton "Hide System Processes"
execute_cmd('Hide System', State, _Data, Args) ->
[_Text, _Group, Bool|_Rest] = Args,
State2 = State#state{hide_system=Bool},
refresh(State2);
%% Checkbutton "Auto-Hide New"
execute_cmd('Auto Hide New', State, _Data, Args ) ->
[_Text, _Group, Bool|_Rest] = Args,
refresh(State#state{hide_new=Bool});
%% File->Options...
execute_cmd('Default Options', State, _Data, _Args) ->
OldOptions = State#state.options,
NewOptions = pman_options:dialog(State#state.win,
"Default Trace Options",
OldOptions),
case NewOptions of
{error, _Reason} ->
State;
Options ->
State#state{options=Options}
end;
%% File->Save Options
%% Save the set default options to the user's option file
execute_cmd('Save Options', State, _Data, _Args)->
Options = State#state.options,
File = options_file(),
Parent = State#state.win,
case pman_options:save_to_file(Options, File) of
ok ->
tool_utils:notify(Parent, "Options saved to\n" ++ File);
{error, ReasonStr} ->
Msg = io_lib:format("Could not save options to~n~s:~n~s",
[File, ReasonStr]),
tool_utils:notify(Parent, Msg)
end,
State;
%% File->Exit
%% Exit the application
execute_cmd('Exit', _State, _Data, _Args) ->
stop;
%% View->Hide All Processes
execute_cmd('Hide All', State, _Data, _Args) ->
Node = State#state.node,
HideAll = nl_update(Node, true, State#state.hide_all),
ShowPids = nl_del_all(State#state.node, State#state.show_pids),
State2 = State#state{hide_all=HideAll, show_pids=ShowPids},
refresh(State2, true);
%% View->Hide modules...
%% Opens a dialog where the user can select from a list of
%% the loaded modules.
%% The selected module is added to the list of hidden modules.
execute_cmd('Hide Modules', State, _Data, _Args) ->
%% Get all loaded modules that are not already hidden
AllModules = lists:map(fun({Module, _File}) -> Module end,
code:all_loaded()),
ModulesSet = ordsets:subtract(ordsets:from_list(AllModules),
State#state.hide_modules),
%% Let the user select which of the loaded modules to exclude from
%% the process overview
Title = "Module selection",
case pman_tool:select(State#state.win, Title, ModulesSet) of
Modules when is_list(Modules) ->
HideModules = ordsets:union(State#state.hide_modules,
ordsets:from_list(Modules)),
refresh(State#state{hide_modules=HideModules});
cancelled -> State
end;
%% View->Hide Selected Process
%% The process in focus should explicitly be hidden
execute_cmd('Hide Selected Process', State, _Data, _Args) ->
case State#state.focus_pid of
undefined -> State;
Pid ->
Node = State#state.node,
HidePids = nl_add(Node, Pid, State#state.hide_pids),
ShowPids = nl_del(Node, Pid, State#state.show_pids),
refresh(State#state{hide_pids=HidePids, show_pids=ShowPids})
end;
%% View->Module Info...
%% Open window with module information.
execute_cmd('Module', State, _Data, _Args) ->
case get_pid_in_focus(State#state.focus, State#state.grid) of
{true, {pidfunc, _Pid, {Module,_Name,_Arity}}} ->
pman_module_info:start(Module);
_ -> % false | {true, {pidfunc, Pid, Other}}
ignore
end,
State;
%% View->Refresh
%% Refresh the main window.
%% (Called automatically every ?REFRESH_TIME millisecond)
execute_cmd('Refresh', State, _Data, _Args) ->
refresh(State);
%% View->Show All Processes
%% Makes all processes visible except system processes and new
%% processes, if those buttons are checked.
%% Note: Also un-hides all hidden modules!
execute_cmd('Show All', State, _Data, _Args) ->
Node = State#state.node,
HideAll = nl_update(Node, false, State#state.hide_all),
HidePids = nl_del_all(State#state.node, State#state.hide_pids),
ShowPids = nl_del_all(State#state.node, State#state.show_pids),
State2 = State#state{hide_modules=ordsets:new(), hide_all=HideAll,
hide_pids=HidePids, show_pids=ShowPids},
refresh(State2, true);
%% View->Show Processes...
%% Open a list of all hidden processes, if the user selects one this
%% process should explicitly be shown
execute_cmd('Show Selected', State, _Data, _Args) ->
Node = State#state.node,
All = pman_process:r_processes(Node),
Hidden = case nl_lookup(Node, State#state.hide_all) of
true ->
All;
false ->
Shown = nl_lookup(Node, State#state.shown_pids),
ordsets:subtract(All, Shown)
end,
%% Selection window
Title = "Select Processes to Show",
Tuples =
lists:map(fun(Pid) ->
{M,F,A} = pman_process:function_info(Pid),
Str = case pman_process:get_name(Pid) of
" " ->
io_lib:format("~p:~p/~p",
[M, F, A]);
Name ->
io_lib:format("[~p] ~p:~p/~p",
[Name, M, F, A])
end,
{Pid, Str}
end,
Hidden),
case pman_tool:select(State#state.win, Title, Tuples) of
Pids when is_list(Pids) ->
HidePids = nl_del(Node, Pids, State#state.hide_pids),
ShowPids = nl_add(Node, Pids, State#state.show_pids),
refresh(State#state{hide_pids=HidePids,show_pids=ShowPids});
cancelled -> State
end;
%% Trace->Kill
execute_cmd('Kill', State, _Data, _Args) ->
case State#state.focus_pid of
Pid when is_pid(Pid) ->
exit(Pid, kill);
undefined ->
ignore
end,
State;
%% Trace->Selected Process
execute_cmd('Trace Process', State, _Data, _Args) ->
case State#state.focus_pid of
Pid when is_pid(Pid) ->
pman_shell:start({Pid,self()}, State#state.options);
undefined ->
ignore
end,
State;
%% Trace->Shell Process
execute_cmd('Trace Shell', State, _Data, _Args) ->
case pman_shell:find_shell() of
noshell ->
State;
Shell ->
pman_shell:start({{shell,Shell},self()},
State#state.options),
State#state{noshell=false}
end;
%% Nodes->Show <Node>
%% Change shown node
execute_cmd({node,Node}, State, _Data, _Args) ->
gse:config(State#state.win,
[{title,lists:concat(["Pman: Overview on ", Node])}]),
gse:disable(Node),
catch gse:enable(State#state.node), % Menu may not exist any more
refresh(State#state{node=Node}, true);
%% Help->Help
execute_cmd('Help', State, _Data, _Args) ->
Win = State#state.win,
HelpFile =
filename:join([code:lib_dir(pman),"doc","html","index.html"]),
tool_utils:open_help(Win, HelpFile),
State;
%% Keyboard shortcut Ctrl-l
execute_cmd('All Links', State, _Data, _Args) ->
case State#state.focus_pid of
Pid when is_pid(Pid) ->
case process_info(Pid, links) of
{links, Pids} ->
pman_shell:start_list(Pids, self(),
State#state.options);
undefined ->
ignore
end;
undefined -> ignore
end,
State;
%% Keyboard shortcuts for process grid traversal
execute_cmd(focus_previous, State, _Data, _Args) ->
focus(previous_row(State), State);
execute_cmd(focus_next, State, _Data, _Args) ->
focus(next_row(State), State);
%% Keyboard combinations that are not shortcuts
execute_cmd(dummy, State, _Data, _Args) ->
State.
%% Convenience functions for disabling/enabling menu items that require
%% that a process is selected.
disable_pid_actions() ->
lists:foreach(fun(X) -> gse:disable(X) end, ?REQUIRES_FOCUS).
enable_pid_actions() ->
lists:foreach(fun(X) -> gse:enable(X) end, ?REQUIRES_FOCUS).
%% refresh(State) -> State'
%% refresh(State, ForceP) -> State'
%% Refreshes the main window.
refresh(State) ->
refresh(State, false).
refresh(#state{node=Node} = State, ForceP) ->
%% Update shown processes
%% First, get an ordset of all processes running at the current node
All = pman_process:r_processes(Node),
Shown = nl_lookup(Node, State#state.shown_pids),
ExpShown = nl_lookup(Node, State#state.show_pids),
{Show, State2} =
case nl_lookup(Node, State#state.hide_all) of
%% If the user has selected "Hide All Processes", only
%% explicitly selected processes which still exist should
%% be shown
true ->
{ordsets:intersection(ExpShown, All), State};
false ->
%% Compute which processes should be hidden according
%% to the flags/menu items selected
Hidden = hidden_pids(All, State),
NotHidden = ordsets:subtract(All, Hidden),
Show0 = case State#state.hide_new of
%% If the user has selected "Auto-Hide New",
%% then only those processes in NotHidden
%% which are already shown, should be shown,
%% together with explicitly selected
%% processes which still exist
true ->
ordsets:union(
ordsets:intersection(NotHidden,Shown),
ordsets:intersection(ExpShown, All));
%% Otherwise, show all processes in
%% NotHidden, together with explicitly
%% selected processes which still exist
false ->
ordsets:union(
NotHidden,
ordsets:intersection(ExpShown, All))
end,
ShownPids = nl_update(Node, Show0,
State#state.shown_pids),
{Show0, State#state{shown_pids=ShownPids}}
end,
NoOfHidden = length(All) - length(Show),
if
Show==Shown, not ForceP ->
pman_win:update(NoOfHidden),
State;
true ->
ShowInfo = display_info(Show),
pman_win:update(State#state.grid, ShowInfo, NoOfHidden),
%% Set the focus appropriately
State3 = case State2#state.focus_pid of
undefined ->
disable_pid_actions(),
State2;
Pid ->
Row = get_row(Pid, Show),
focus(Row, State2)
end,
trace_shell_possible(State3),
Size = length(Show),
case Size of
1 -> gse:disable('Hide All');
_ -> gse:enable('Hide All')
end,
State3#state{size=Size}
end.
%% hidden_pids(All, State) -> Hidden
hidden_pids(All, State) ->
%% Processes hidden because they are system processes
HideSys = case State#state.hide_system of
true ->
lists:filter(
fun(Pid) ->
pman_process:is_system_process(Pid)
end,
All);
false ->
[]
end,
%% Process hidden because they are executing code in a hidden module
Mods = State#state.hide_modules,
HideMod =
lists:filter(fun(Pid) ->
pman_process:is_hidden_by_module(Pid, Mods)
end,
All),
%% Explicitly hidden processes
HideExp = nl_lookup(State#state.node, State#state.hide_pids),
%% All hidden processes
ordsets:union([HideSys, HideMod, HideExp]).
display_info(Pids) ->
lists:map(fun(Pid) ->
Func = pman_process:function_info(Pid),
Name = pman_process:get_name(Pid),
Msgs = pman_process:msg(Pid),
Reds = pman_process:reds(Pid),
Size = pman_process:psize(Pid),
{Pid, Func, Name, Msgs, Reds, Size}
end,
Pids).
get_row(Pid, List) ->
get_row(Pid, List, length(List)+1).
get_row(Pid, [Pid | _], Row) ->
Row;
get_row(Pid, [_ | T], Row) ->
get_row(Pid, T, Row-1);
get_row(_Pid, [], _Row) ->
1.
next_row(#state{size=Size, focus=Row}) ->
check_row(Row+1, Size).
previous_row(#state{size=Size, focus=Row}) ->
check_row(Row-1, Size).
check_row(1, Size) ->
Size+1;
check_row(Row, Size) when Row==Size+2 ->
2;
check_row(Row, _Size) ->
Row.
%% Check if node is running in noshell mode and if so disable the
%% 'Trace Shell' menu option.
trace_shell_possible(#state{noshell=true}) ->
gse:disable('Trace Shell');
trace_shell_possible(_) ->
ok.
%% -- Functions for manipulating {Node, Data} lists --
%% nl_add(Node, Elem|Elems, NList) -> NList'
nl_add(Node, Elems, [{Node, Ordset} | T]) when is_list(Elems) ->
[{Node, ordsets:union(Elems, Ordset)} | T];
nl_add(Node, Elem, [{Node, Ordset} | T]) ->
[{Node, ordsets:add_element(Elem, Ordset)} | T];
nl_add(Node, Elem, [H | T]) ->
[H | nl_add(Node, Elem, T)];
nl_add(Node, Elems, []) when is_list(Elems) ->
[{Node, Elems}];
nl_add(Node, Elem, []) ->
[{Node, ordsets:add_element(Elem, ordsets:new())}].
%% nl_del(Node, Elem|Elems, NList) -> NList'
nl_del(Node, Elems, [{Node, Ordset} | T]) when is_list(Elems) ->
[{Node, ordsets:subtract(Ordset, Elems)} | T];
nl_del(Node, Elem, [{Node, Ordset} | T]) ->
[{Node, ordsets:del_element(Elem, Ordset)} | T];
nl_del(Node, Elem, [H | T]) ->
[H | nl_del(Node, Elem, T)];
nl_del(_Node, _Elem, []) ->
[].
%% nl_del_all(Node, NList) -> NList'
nl_del_all(Node, [{Node, _Ordset} | T]) ->
[{Node, ordsets:new()} | T];
nl_del_all(Node, [H | T]) ->
[H | nl_del_all(Node, T)];
nl_del_all(_Node, []) ->
[].
%% nl_update(Node, Val, NList) -> NList'
nl_update(Node, Val, [{Node, _OldVal} | T]) ->
[{Node, Val} | T];
nl_update(Node, Val, [H | T]) ->
[H | nl_update(Node, Val, T)];
nl_update(Node, Val, []) ->
[{Node, Val}].
%% nl_lookup(Node, NList) -> Val
nl_lookup(Node, NList) ->
{value, {_Node,Val}} = lists:keysearch(Node, 1, NList),
Val.
%% nl_exists(Node, NList) -> bool()
nl_exists(Node, NList) ->
case lists:keysearch(Node, 1, NList) of
{value, _Val} ->
true;
false ->
false
end.
