fairchild-poolparty 1.1.3

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

@@ -0,0 +1,49 @@
+-module (pm_client).
+-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_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

@@ -0,0 +1,61 @@
+-module(pm_cluster).
+
+-ifdef(EUNIT).
+-include_lib("eunit/include/eunit.hrl").
+-endif.
+
+-include_lib("../include/defines.hrl").
+
+-export ([slaves/1, slaves/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]).
+
+master() ->
+	{erlang:node()}.
+
+slaves([]) ->
+	ok;
+
+slaves([Host|Hosts]) ->
+	Args = erl_system_args(),
+	NodeName = "pp",
+	{ok, Node} = slave:start_link(Host, NodeName, Args),
+	io:format("Erlang node started = [~p]~n", [Node]),
+	slaves(Hosts).
+
+slaves() ->	get_live_nodes().
+
+erl_system_args()->
+	Shared = case init:get_argument(shared) of
+		error -> " ";
+		{ok,[[]]} -> " -shared "
+	end,
+	lists:append(
+		["-rsh ssh -setcookie", 
+		atom_to_list(erlang:get_cookie()),
+		Shared, " +Mea r10b "
+	]).
+
+any_new_servers() ->
+	String = ". /etc/profile && server-list-active -c name",
+	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() ->
+	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

@@ -0,0 +1,215 @@
+%%%-------------------------------------------------------------------
+%%% File    : pm_master.erl
+%%% Author  : Ari Lerner <arilerner@mac.com>
+%%% The client is a running process that will run on the master node
+%%% and spawn requests to the pm_nodes and compile the responses
+%%% for use within the poolparty network
+%%%-------------------------------------------------------------------
+-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
+
+%% gen_server callbacks
+-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]).
+-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, ?MODULE}, ?MODULE, [], []).
+
+%%====================================================================
+%% gen_server callbacks
+%%====================================================================
+
+%%--------------------------------------------------------------------
+%% Function: init(Args) -> {ok, State} |
+%%                         {ok, State, Timeout} |
+%%                         ignore               |
+%%                         {stop, Reason}
+%% Description: Initiates the server
+%%--------------------------------------------------------------------
+init([]) ->
+	% 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} |
+%%                                      {reply, Reply, State, Timeout} |
+%%                                      {noreply, State} |
+%%                                      {noreply, State, Timeout} |
+%%                                      {stop, Reason, Reply, State} |
+%%                                      {stop, Reason, State}
+%% Description: Handling call messages
+%%--------------------------------------------------------------------
+% 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 puppet needs
+handle_call({clear_cert_for, Name}, _From, State) ->
+	String = string:concat(". /etc/profile && /usr/bin/puppetcleaner ",Name),
+	os:cmd(String),
+	{reply, ok, 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} |
+%%                                      {noreply, State, Timeout} |
+%%                                      {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}.
+
+%%--------------------------------------------------------------------
+%% Function: handle_info(Info, State) -> {noreply, State} |
+%%                                       {noreply, State, Timeout} |
+%%                                       {stop, Reason, State}
+%% Description: Handling all non call/cast messages
+%%--------------------------------------------------------------------
+handle_info(_Info, State) ->
+  {noreply, State}.
+
+%%--------------------------------------------------------------------
+%% Function: terminate(Reason, State) -> void()
+%% Description: This function is called by a gen_server when it is about to
+%% terminate. It should be the opposite of Module:init/1 and do any necessary
+%% cleaning up. When it returns, the gen_server terminates with Reason.
+%% The return value is ignored.
+%%--------------------------------------------------------------------
+terminate(_Reason, _State) ->
+  ok.
+
+%%--------------------------------------------------------------------
+%% Func: code_change(OldVsn, State, Extra) -> {ok, NewState}
+%% Description: Convert process state when code is changed
+%%--------------------------------------------------------------------
+code_change(_OldVsn, State, _Extra) ->
+  {ok, State}.
+
+% 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

@@ -0,0 +1,39 @@
+% This supervisor is responsible for monitoring the 
+% client service
+
+-module (pm_master_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
+	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}}.