poolparty 0.2.18 → 0.2.69

data/lib/erlang/messenger/src/pm_client.erl

@@ -1,19 +1,49 @@
 -module (pm_client).
--export ([init/0, send_cmd/1, reconfigure_cloud/0, get_load/1, get_live_nodes/0]).
--export ([shutdown/0]).
-% Run commands on the running master process
-% erl -pa ./ebin/ -run pm_client get_load cpu -run init stop -noshell
-
-% Connect to the master
-init() -> net_adm:ping(master).
-% Send the command Cmd to the pm_master process
-send_cmd(Cmd) ->	pm_master:fire_cmd(Cmd).
-% Reconfigure the cloud
-reconfigure_cloud() -> pm_master:reconfigure_cloud().
-% Get the load on the cloud of type Type
-get_load(Type) -> pm_master:get_load(Type).
-% Get a list of the live nodes
-get_live_nodes() -> pm_master:get_live_nodes().
-% Terminate the cloud messenger
-% This sends a shutdown to the whole cloud
-shutdown() -> pm_master:shutdown_cloud().
+-behavior(gen_server).
+
+-export([init/1, code_change/3, handle_call/3, handle_cast/2, handle_info/2, terminate/2]).
+-export([accept_loop/1]).
+-export([start/3]).
+
+-define(TCP_OPTIONS, [binary, {packet, 0}, {active, false}, {reuseaddr, true}]).
+
+-record(server_state, {
+        port,
+        loop,
+        ip=any,
+        lsocket=null}).
+
+start(Name, Port, Loop) ->
+    State = #server_state{port = Port, loop = Loop},
+    gen_server:start_link({global, Name}, ?MODULE, State, []).
+
+init(State = #server_state{port=Port}) ->
+		process_flag(trap_exit, true),
+    case gen_tcp:listen(Port, ?TCP_OPTIONS) of
+        {ok, LSocket} ->
+            NewState = State#server_state{lsocket = LSocket},
+            {ok, accept(NewState)};
+        {error, Reason} ->
+            {stop, Reason}
+    end.
+
+handle_cast({accepted, _Pid}, State=#server_state{}) ->
+    {noreply, accept(State)}.
+
+accept_loop({Server, LSocket, {M, F}}) ->
+    {ok, Socket} = gen_tcp:accept(LSocket),
+    % Let the server spawn a new process and replace this loop
+    % with the echo loop, to avoid blocking 
+    gen_server:cast(Server, {accepted, self()}),
+    M:F(Socket).
+    
+% To be more robust we should be using spawn_link and trapping exits
+accept(State = #server_state{lsocket=LSocket, loop = Loop}) ->
+    proc_lib:spawn(?MODULE, accept_loop, [{self(), LSocket, Loop}]),
+    State.
+
+% These are just here to suppress warnings.
+handle_call(_Msg, _Caller, State) -> {noreply, State}.
+handle_info(_Msg, Library) -> {noreply, Library}.
+terminate(_Reason, _Library) -> ok.
+code_change(_OldVersion, Library, _Extra) -> {ok, Library}.

data/lib/erlang/messenger/src/pm_client_old.erl

@@ -0,0 +1,52 @@
+-module (pm_client_old).
+-include_lib("../include/defines.hrl").
+
+-export ([reconfigure_cloud/0, get_load/1, get_live_nodes/0, start/0]).
+-export ([run_cmd/1, fire_cmd/1]).
+-export ([provision_orphan_running_servers/0]).
+-export ([shutdown/0]).
+% Run commands on the running master process
+% erl -pa ./ebin/ -run pm_client get_load cpu -run init stop -noshell
+
+% Connect to the master
+start() -> 
+	pong = net_adm:ping(?MASTER_LOCATION),
+	global:sync().
+% Send the command Cmd to the pm_master process
+run_cmd(Cmd) ->	
+	Out = pm_master:run_cmd(Cmd),
+	io:format("~p", [Out]),
+	Out.
+fire_cmd(Cmd) ->	
+	Out = pm_master:fire_cmd(Cmd),
+	io:format("~p", [Out]),
+	Out.
+% Reconfigure the cloud
+reconfigure_cloud() -> pm_master:reconfigure_cloud().
+% Get the load on the cloud of type Type
+get_load(Type) -> 
+	start(),
+	Load = pm_master:get_load(Type),
+	io:format("~p", [Load]),
+	Load.
+	
+% Check to see if there are servers that are unprovisioned
+% And if there are, log in to them and start their messenger
+% sending the live code on the master to them
+provision_orphan_running_servers() ->
+	Instances = pm_cluster:any_new_servers(),
+	case lists:flatlength(Instances) of
+		0 ->
+			ok;
+		_ ->
+			utils:distribute_modules_to([pm_node, pm_node_supervisor, pm_event_manager, node_app], Instances),
+			pm_cluster:slaves(Instances),
+			Instances
+	end.
+
+% Get a list of the live nodes
+get_live_nodes() -> pm_master:get_current_nodes().
+% Terminate the cloud messenger
+% This sends a shutdown to the whole cloud
+shutdown() -> 
+	pm_master:shutdown_cloud().

data/lib/erlang/messenger/src/pm_client_supervisor.erl

@@ -0,0 +1,38 @@
+% This supervisor is responsible for monitoring the 
+% client service
+
+-module (pm_client_supervisor).
+-behaviour(supervisor).
+
+-export([start/0, start_in_shell_for_testing/0, start_link/1, init/1]).
+
+-ifdef(EUNIT).
+-include_lib("eunit/include/eunit.hrl").
+-endif.
+
+start() ->
+	spawn(fun() ->
+			supervisor:start_link({local, ?MODULE}, ?MODULE, _Arg = [])
+		end).
+
+start_in_shell_for_testing() ->
+	{ok, Pid} = supervisor:start_link({local, ?MODULE}, ?MODULE, _Arg = []),
+	unlink(Pid).
+
+start_link(Args) ->
+	supervisor:start_link({local, ?MODULE}, ?MODULE, Args).	
+
+init([]) ->
+	RestartStrategy = one_for_one,
+	MaxRestarts = 1000,
+	MaxTimeBetRestarts = 3600,
+	TimeoutTime = 5000,
+
+	SupFlags = {RestartStrategy, MaxRestarts, MaxTimeBetRestarts},
+	
+	% Servers
+	ClientServer = {client_server1,  {client_server, start, []}, permanent, TimeoutTime, worker, [client_server]},
+	
+	LoadServers = [ClientServer],
+
+	{ok, {SupFlags, LoadServers}}.

data/lib/erlang/messenger/src/pm_cluster.erl

@@ -4,10 +4,15 @@
 -include_lib("eunit/include/eunit.hrl").
 -endif.
 
+-include_lib("../include/defines.hrl").
+
 -export ([slaves/1, slaves/0]).
--export ([get_live_nodes/0,refresh_live_nodes/0]).
+-export ([get_live_nodes/0]).
 -export ([send_call/2, master/0]).
 
+-export ([any_new_servers/0]).
+
+% gen_server:call(?MASTER_SERVER, {Type, Args}).
 send_call(Type, Args) ->
 	Nodes = get_live_nodes(),
 	rpc:multicall(Nodes, pm_node, Type, [Args]).
@@ -20,13 +25,12 @@ slaves([]) ->
 
 slaves([Host|Hosts]) ->
 	Args = erl_system_args(),
-	NodeName = "pp_cluster",
+	NodeName = "pp",
 	{ok, Node} = slave:start_link(Host, NodeName, Args),
 	io:format("Erlang node started = [~p]~n", [Node]),
 	slaves(Hosts).
 
-slaves() ->
-	get_live_nodes().
+slaves() ->	get_live_nodes().
 
 erl_system_args()->
 	Shared = case init:get_argument(shared) of
@@ -39,19 +43,19 @@ erl_system_args()->
 		Shared, " +Mea r10b "
 	]).
 
-refresh_live_nodes() ->
+any_new_servers() ->
 	String = ". /etc/profile && server-list-active -c name",
-	Nodes = string:tokens(os:cmd(String), "\n\t"),
-	io:format("nodes: ~p~n", [Nodes]),
-	lists:map(
-		fun(No) ->
-			io:format("pinging ~p~n", [list_to_atom(lists:append("pp_cluster@",No))]),
-			net_adm:ping(list_to_atom(lists:append("@pp_cluster", No)))
-		end,
-		Nodes),
-	ok.
-% Get the live nodes
+	NodesFromActive = lists:map(fun
+		(No) ->
+			erlang:list_to_atom(lists:append([No, "@", No]))
+	end,string:tokens(os:cmd(String), "\n\t")),
+	% Nodes -- get_live_nodes(),
+	NewServers = [X || X <- NodesFromActive, (lists:member(X, get_live_nodes()) /= true) ],
+	NewServers.
+	
+% Get the live nodes that are NOT client nodes
 get_live_nodes() ->
-	nodes().
+	ClientString = "client",
+	[X || X <- nodes(), (erlang:is_atom(regexp:first_match(erlang:atom_to_list(X), ClientString))) ].
 %% Do not forget to start erlang with a command like:
 %% erl -rsh ssh -sname clustmaster

data/lib/erlang/messenger/src/pm_event_manager.erl

@@ -0,0 +1,27 @@
+-module (pm_event_manager).
+-include_lib("../include/defines.hrl").
+
+%% API
+-export([start_link/0, add_handler/1, notify/1]).
+-define(SERVER, ?MODULE).
+
+%%--------------------------------------------------------------------
+%% Function: start_link() -> {ok,Pid} | {error,Error}
+%% Description: Creates an event manager.
+%%--------------------------------------------------------------------
+start_link() ->
+  gen_event:start_link({local, ?SERVER}).
+
+%%--------------------------------------------------------------------
+%% Function: add_handler(Module) -> ok | {'EXIT',Reason} | term()
+%% Description: Adds an event handler
+%%--------------------------------------------------------------------
+add_handler(Module) ->
+  gen_event:add_handler(?SERVER, Module, []).
+
+%%--------------------------------------------------------------------
+%% Function: notify(Event) -> ok | {error, Reason}
+%% Description: Sends the Event through the event manager.
+%%--------------------------------------------------------------------
+notify(Event) ->
+  gen_event:notify(?SERVER, Event).

data/lib/erlang/messenger/src/pm_master.erl

@@ -8,28 +8,65 @@
 -module(pm_master).
 -behaviour(gen_server).
 
+-include_lib("../include/defines.hrl").
+
+-record(state, {
+					nodes = ?DICT:new()  % Dictionary of running nodes
+				}).
+				
+-define (SERVER, global:whereis_name(?MODULE)).
+
 %% API
--export([start_link/0]).
 
 %% gen_server callbacks
--export([init/1, handle_call/3, handle_cast/2, handle_info/2,
-         terminate/2, code_change/3]).
--record(state, {}).
--define(SERVER, ?MODULE).
+-export([start_link/0,
+         stop/0,
+         init/1,
+         handle_call/3,
+         handle_cast/2,
+         handle_info/2,
+         terminate/2,
+         code_change/3]).
 
 % Client function definitions
--export ([get_load/1, reconfigure_cloud/0, fire_cmd/1]).
+-export ([get_load/1, reconfigure_cloud/0]).
+-export ([run_cmd/1, fire_cmd/1, get_current_nodes/0]).
 -export ([shutdown_cloud/0]).
 
 %%====================================================================
 %% API
 %%====================================================================
 %%--------------------------------------------------------------------
+%%% Internal functions
+%%--------------------------------------------------------------------
+
+% pm_master:get_load("cpu").
+get_load(Type) ->
+	% {Loads, _} = pm_cluster:send_call(get_load_for_type, [Type]),
+	% {Loads, _} = gen_server:call(?SERVER, {get_load, [Type]}),
+	gen_server:call(?SERVER, {get_current_load, Type}).
+
+% Send reconfigure tasks to every node
+reconfigure_cloud() -> gen_server:cast(?SERVER, {force_reconfig}).
+
+% Fire the given command on all nodes
+run_cmd(Cmd) -> gen_server:call(?SERVER, {run_cmd, Cmd}).
+fire_cmd(Cmd) -> gen_server:call(?SERVER, {fire_cmd, Cmd}).
+	
+% Shutdown
+shutdown_cloud() ->
+	pm_cluster:send_call(stop, []),
+	{ok}.
+
+get_current_nodes() -> gen_server:call(?SERVER, {get_current_nodes, []}).
+
+stop() -> gen_server:cast(?MODULE, stop).	
+%%--------------------------------------------------------------------
 %% Function: start_link() -> {ok,Pid} | ignore | {error,Error}
 %% Description: Starts the server
 %%--------------------------------------------------------------------
 start_link() ->
-  gen_server:start_link({global, ?SERVER}, ?MODULE, [], []).
+  gen_server:start_link({global, ?MODULE}, ?MODULE, [], []).
 
 %%====================================================================
 %% gen_server callbacks
@@ -43,7 +80,11 @@ start_link() ->
 %% Description: Initiates the server
 %%--------------------------------------------------------------------
 init([]) ->
-  {ok, #state{}}.
+	% pm_event_manager:add_handler(pm_master_event_handler),
+	process_flag(trap_exit, true),
+  {ok, #state{
+		nodes = ?DICT:new()
+	}}.
 
 %%--------------------------------------------------------------------
 %% Function: %% handle_call(Request, From, State) -> {reply, Reply, State} |
@@ -54,9 +95,23 @@ init([]) ->
 %%                                      {stop, Reason, State}
 %% Description: Handling call messages
 %%--------------------------------------------------------------------
-handle_call(_Request, _From, State) ->
-  Reply = ok,
-  {reply, Reply, State}.
+% Handle load messages
+handle_call({get_load, Args}, _From, State) ->
+		Nodes = pm_cluster:get_live_nodes(),
+		List = rpc:multicall(Nodes, pm_node, get_load_for_type, [Args]),
+		Loads = utils:convert_responses_to_int_list(List),
+		{reply, Loads, State};
+handle_call({get_current_load, Types}, _From, State) ->	
+	LoadForType = [utils:average_of_list(get_load_for_type(Type, State)) || Type <- Types],
+	?TRACE("LoadForType: ",[LoadForType]),
+	{reply, LoadForType, State};
+handle_call({get_current_nodes, _Args}, _From, State) ->
+	{reply, get_live_nodes(State), State}.
+	
+% handle_call(_Request, _From, State) ->
+	% Nodes = pm_cluster:get_live_nodes(),
+	% Reply = Reply = rpc:multicall(Nodes, pm_node, Request, []),
+	% {reply, Reply, State}.
 
 %%--------------------------------------------------------------------
 %% Function: handle_cast(Msg, State) -> {noreply, State} |
@@ -64,6 +119,18 @@ handle_call(_Request, _From, State) ->
 %%                                      {stop, Reason, State}
 %% Description: Handling cast messages
 %%--------------------------------------------------------------------
+handle_cast({update_node_load, From, Loads}, State) ->
+	% ?TRACE("Cast with load message", [From, Loads]),
+	% {_Nodes, NewState} = get_node_listing(From, State),
+	% {noreply, NewState};
+	{_LoadState, NewState} = store_load_for(From, Loads, State),
+	{noreply, NewState};
+handle_cast({force_reconfig}, State) ->
+	Fun = fun(NodeEntry) ->
+		{_Node, Pid} = NodeEntry,
+		gen_server:cast(Pid, {reconfig}) end,
+	run_on_nodes(Fun, State),
+	{noreply, State};
 handle_cast(_Msg, State) ->
   {noreply, State}.
 
@@ -93,26 +160,51 @@ terminate(_Reason, _State) ->
 code_change(_OldVsn, State, _Extra) ->
   {ok, State}.
 
-%%--------------------------------------------------------------------
-%%% Internal functions
-%%--------------------------------------------------------------------
-
-% pm_master:get_load("0", "cpu").
-get_load(Type) ->
-	{Loads, _} = pm_cluster:send_call(get_load_for_type, [Type]),
-	{utils:convert_responses_to_int_list(Loads)}.
-
-% Send reconfigure tasks to every node
-reconfigure_cloud() ->
-	pm_cluster:send_call(run_reconfig, []),
-	{ok}.
-
-% Fire the given command on all nodes
-fire_cmd(Cmd) ->
-	pm_cluster:send_call(fire_cmd, [Cmd]),
-	{ok}.
-
-% Shutdown
-shutdown_cloud() ->
-	pm_cluster:send_call(stop, []),
-	{ok}.
+% Private methods
+get_node_listing(Name, State) ->
+	% Find or create the stored node	
+	case ?DICT:is_key(Name, State#state.nodes) of
+		true -> NodeStore = ?DICT:fetch(Name, State#state.nodes), {NodeStore, State};
+		false -> 
+			NodeStore = {},  NewState = State#state{nodes = ?DICT:store(Name, NodeStore, State#state.nodes)}, {NodeStore, NewState}
+	end.
+
+get_load_for_type(Type, State) ->
+	Loads = [ get_load_for_node(Type, Name, State) || Name <- get_live_nodes(State) ],
+	[Load || Load <- Loads, Load =/= false, Load > 0.0].
+
+get_load_for_node(Type, Name, State) ->
+	{NodeStore, _} = get_node_listing(Name, State),
+	case proplists:is_defined(erlang:list_to_atom(Type), NodeStore) of
+		true -> proplists:get_value(erlang:list_to_atom(Type), NodeStore);
+		_ -> false
+	end.
+
+get_node_pids(State) ->
+	Nodes = dict:fetch_keys(State#state.nodes),	
+	[ {Node, global:whereis_name(Node)} || Node <- Nodes, global:whereis_name(Node) =/= undefined].
+	
+get_live_nodes(State) ->
+	NodePids = get_node_pids(State),
+	RespondingNodes = lists:map(
+	fun(NodeEntry) ->
+		{Node, Pid} = NodeEntry,
+		case is_pid(Pid) of
+			true ->
+				case gen_server:call(Pid, {still_there}) of
+					still_here -> Node;
+					_ -> false
+				end;
+			false -> false
+		end
+	end, NodePids),
+	[ Node || Node <- RespondingNodes, Node =/= false].
+
+run_on_nodes(Fun, State) ->
+	NodePids = get_node_pids(State),
+	lists:map(Fun, NodePids).
+	
+store_load_for(Name, Loads, State) ->
+	NewNodeEntry = [ {erlang:list_to_atom(Key), proplists:get_value(Key, Loads)} || Key <- proplists:get_keys(Loads)],
+	NewState = ?DICT:store(Name, NewNodeEntry, State#state.nodes),
+	{NewNodeEntry, State#state{nodes = NewState}}.

data/lib/erlang/messenger/src/pm_master_event_handler.erl

@@ -0,0 +1,72 @@
+-module (pm_master_event_handler).
+-behaviour(gen_event).
+-include_lib("../include/defines.hrl").
+
+%% gen_event callbacks
+-export([init/1, handle_event/2, handle_call/2,
+         handle_info/2, terminate/2, code_change/3]).
+
+%%====================================================================
+%% gen_event callbacks
+%%====================================================================
+%%--------------------------------------------------------------------
+%% Function: init(Args) -> {ok, State}
+%% Description: Whenever a new event handler is added to an event manager,
+%% this function is called to initialize the event handler.
+%%--------------------------------------------------------------------
+init([]) ->
+  {ok, []}.
+
+%%--------------------------------------------------------------------
+%% Function:
+%% handle_event(Event, State) -> {ok, State} |
+%%                               {swap_handler, Args1, State1, Mod2, Args2} |
+%%                               remove_handler
+%% Description:Whenever an event manager receives an event sent using
+%% gen_event:notify/2 or gen_event:sync_notify/2, this function is called for
+%% each installed event handler to handle the event.
+%%--------------------------------------------------------------------
+handle_event(_Event, State) ->
+  {ok, State}.
+
+%%--------------------------------------------------------------------
+%% Function:
+%% handle_call(Request, State) -> {ok, Reply, State} |
+%%                                {swap_handler, Reply, Args1, State1,
+%%                                  Mod2, Args2} |
+%%                                {remove_handler, Reply}
+%% Description: Whenever an event manager receives a request sent using
+%% gen_event:call/3,4, this function is called for the specified event
+%% handler to handle the request.
+%%--------------------------------------------------------------------
+handle_call(_Request, State) ->
+  Reply = ok,
+  {ok, Reply, State}.
+
+%%--------------------------------------------------------------------
+%% Function:
+%% handle_info(Info, State) -> {ok, State} |
+%%                             {swap_handler, Args1, State1, Mod2, Args2} |
+%%                              remove_handler
+%% Description: This function is called for each installed event handler when
+%% an event manager receives any other message than an event or a synchronous
+%% request (or a system message).
+%%--------------------------------------------------------------------
+handle_info(_Info, State) ->
+  {ok, State}.
+
+%%--------------------------------------------------------------------
+%% Function: terminate(Reason, State) -> void()
+%% Description:Whenever an event handler is deleted from an event manager,
+%% this function is called. It should be the opposite of Module:init/1 and
+%% do any necessary cleaning up.
+%%--------------------------------------------------------------------
+terminate(_Reason, _State) ->
+  ok.
+
+%%--------------------------------------------------------------------
+%% Function: code_change(OldVsn, State, Extra) -> {ok, NewState}
+%% Description: Convert process state when code is changed
+%%--------------------------------------------------------------------
+code_change(_OldVsn, State, _Extra) ->
+  {ok, State}.

data/lib/erlang/messenger/src/pm_master_supervisor.erl

@@ -24,17 +24,16 @@ start_link(Args) ->
 
 init([]) ->
 	RestartStrategy = one_for_one,
-	MaxRestarts = 3, % 1000
-	MaxTimeBetRestarts = 30, % 3600
+	MaxRestarts = 1000,
+	MaxTimeBetRestarts = 3600,
+	TimeoutTime = 5000,
 
 	SupFlags = {RestartStrategy, MaxRestarts, MaxTimeBetRestarts},
-
-	LoadServers = [
-		{pm_master1, 
-			{pm_master, start_link, []}, 
-			permanent, 5000, worker, 
-			[pm_master]
-		}
-	],
+	
+	% Servers
+	EventManager = {pm_event_manager,  {pm_event_manager, start_link, []}, permanent, TimeoutTime, worker, dynamic},
+	MasterServer = {pm_master1,  {pm_master, start_link, []}, permanent, TimeoutTime, worker, [pm_master]},	
+	
+	LoadServers = [EventManager,MasterServer],
 
 	{ok, {SupFlags, LoadServers}}.