fairchild-poolparty 1.1.4 → 1.1.5

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

@@ -1,49 +0,0 @@
--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

@@ -1,38 +0,0 @@
-% 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

@@ -1,61 +0,0 @@
--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

@@ -1,27 +0,0 @@
--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

@@ -1,215 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% 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

@@ -1,72 +0,0 @@
--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

@@ -1,39 +0,0 @@
-% 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}}.