fairchild-poolparty 1.1.3

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

@@ -0,0 +1,200 @@
+%%%-------------------------------------------------------------------
+%%% File    : pm_node.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_node).
+-behaviour(gen_server).
+
+-include_lib("../include/defines.hrl").
+
+%% API
+-export([start_link/1, 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, {
+					monitors = {},  % Tuple of monitors
+					stored_loads = ?DICT:new() % Dictionary of latest loads
+				}).
+-define(SERVER, ?MODULE).
+
+% Client function definitions
+-export ([stop/0]).
+-export ([get_current_load_for_type/1, run_cmd/1, fire_cmd/1]).
+-export ([run_reconfig/0, local_update/1, still_here/0, print_monitors/0]).
+-export ([server_location/0]).
+%%====================================================================
+%% API
+%%====================================================================
+%%--------------------------------------------------------------------
+%%% Internal functions
+%%--------------------------------------------------------------------
+
+
+% Get the load for the type sent...
+get_current_load_for_type(Type) ->
+	String = string:concat(". /etc/profile && server-get-load ",Type),
+	LatestLoad = os:cmd(String), 
+	Load = gen_server:call(server_location(), {update_load, Type, LatestLoad}),
+	{Load}.
+
+get_load_listing(Type, State) ->
+	% Find or create the stored node
+	case ?DICT:is_key(Type, State#state.stored_loads) of
+		true -> 
+			LoadStore = ?DICT:fetch(Type, State#state.stored_loads), 
+			{LoadStore, State};
+		false -> 
+			LoadStore = [],
+			NewState = State#state{stored_loads = ?DICT:store(Type, LoadStore, State#state.stored_loads)}, 
+			{LoadStore, NewState}
+	end.
+
+get_average_load_listing(Type, State) ->
+	{LoadListing, _} = get_load_listing(Type, State),
+	utils:average_of_list(LoadListing).
+% Get the stored load for the type
+% Only store the latest NUM_LOADS_TO_STORE in the stored_loads array
+store_load_for_type(Type, Load, State) ->
+	{LoadStore, LoadListingState} = get_load_listing(Type, State),	
+	LoadList = lists:reverse(LoadStore),
+	case length(LoadList) >= ?NUM_LOADS_TO_STORE of
+		true -> [_|T] = LoadList; 
+		false -> T = LoadList
+	end,
+	NewStoredLoad = lists:append([Load], lists:reverse(T)),	
+	NewState = State#state{stored_loads = ?DICT:store(Type, NewStoredLoad, LoadListingState#state.stored_loads)},	
+	{Type, NewState}.
+	
+% Rerun the configuration
+run_reconfig() -> gen_server:cast(server_location(), {run_reconfig}).
+print_monitors() -> gen_server:call(server_location(), {print_monitors}).
+
+% Allows us to fire off any command (allowed by poolparty on the check)
+run_cmd(Cmd) -> gen_server:call(server_location(), {run_command, Cmd}).
+fire_cmd(Cmd) -> gen_server:cast(server_location(), {fire_command, Cmd}).
+
+still_here() -> gen_server:call(server_location(), {still_there}).
+
+% Stop the pm_node entirely
+stop() -> gen_server:cast(server_location(), stop).
+
+% Run every UPDATE_TIME seconds
+local_update(Types) ->
+	?TRACE("Updating", [?MASTER_LOCATION]),	
+	net_adm:ping(?MASTER_LOCATION), % check in with the master
+	Load = [{Ty, element(1, get_current_load_for_type(Ty))} || Ty <- Types],
+	gen_server:cast(?MASTER_SERVER, {update_node_load, node(), Load}).	
+	
+%%--------------------------------------------------------------------
+%% Function: start_link() -> {ok,Pid} | ignore | {error,Error}
+%% Description: Starts the server
+%% 
+%% Starts the timer to fire off a ping to the master to let the master
+%% know that it is alive
+%% 
+%% Fires a ping every 10 seconds
+%%--------------------------------------------------------------------
+start_link() -> start_link(init:get_plain_arguments()).
+start_link(Args) -> gen_server:start_link({global, node()}, ?MODULE, Args, Args).
+
+%%====================================================================
+%% gen_server callbacks
+%%====================================================================
+
+%%--------------------------------------------------------------------
+%% Function: init(Args) -> {ok, State} |
+%%                         {ok, State, Timeout} |
+%%                         ignore               |
+%%                         {stop, Reason}
+%% Description: Initiates the server
+%%--------------------------------------------------------------------
+init(Args) ->
+	io:format("Master location ~p~n", [?MASTER_LOCATION]),
+	process_flag(trap_exit, true),
+	utils:start_timer(?UPDATE_TIME, fun() -> pm_node:local_update(Args) end),
+  {ok, #state{
+					monitors=Args,
+					stored_loads = ?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_call({run_command, Cmd}, _From, State) ->
+	Reply = os:cmd(Cmd),
+	{reply, Reply, State};
+handle_call({update_load, Type, Load}, _From, State) ->
+	{Type, NewState} = store_load_for_type(Type, Load, State),
+	Reply = get_average_load_listing(Type, NewState),
+	?TRACE("Updated load", [Reply]),
+	{reply, Reply, NewState};
+handle_call({still_there}, _From, State) ->
+	Reply = still_here,
+	{reply, Reply, State};
+handle_call({print_monitors}, _From, State) ->
+	[ io:format("Type: ~p ", [Monitor]) || Monitor <- State#state.monitors ],
+	io:format("~n"),
+	{reply, ok, State};
+handle_call(_Request, _From, State) ->
+  Reply = ok,
+  {reply, Reply, State}.
+
+%%--------------------------------------------------------------------
+%% Function: handle_cast(Msg, State) -> {noreply, State} |
+%%                                      {noreply, State, Timeout} |
+%%                                      {stop, Reason, State}
+%% Description: Handling cast messages
+%%--------------------------------------------------------------------
+handle_cast({fire_command, Cmd}, State) ->
+	?TRACE("Running command: ~p~n", [Cmd]),
+	os:cmd(". /etc/profile && server-fire-cmd \""++Cmd++"\" 2>&1 > /dev/null"),
+	{noreply, State};
+handle_cast({run_reconfig}, State) ->
+	?TRACE("Running Reconfig", ["server-rerun"]),
+	os:cmd(". /etc/profile && server-rerun"),
+	{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) ->
+	io:format("Info message received from: ~p~n", [_Info]),
+	{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) ->
+	utils:stop_timer(),
+  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
+server_location() -> global:whereis_name(node()).

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

@@ -0,0 +1,38 @@
+% This supervisor is responsible for monitoring the 
+% client service
+
+-module (pm_node_supervisor).
+-behaviour(supervisor).
+
+-export ([start/0, start/1]).
+-export([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(Args) -> spawn(fun() -> supervisor:start_link({local, ?MODULE}, ?MODULE, Args) 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(Args) ->
+	RestartStrategy = one_for_one,
+	MaxRestarts = 1000,
+	MaxTimeBetRestarts = 3600,
+	TimeoutTime = 5000,
+
+	SupFlags = {RestartStrategy, MaxRestarts, MaxTimeBetRestarts},
+	
+	EventManager = {pm_event_manager,  {pm_event_manager, start_link, []}, permanent, TimeoutTime, worker, dynamic},
+	NodeServer = {pm_node1, {pm_node, start_link, Args}, permanent, TimeoutTime, worker, [pm_node]},
+
+	LoadServers = [EventManager, NodeServer],
+
+	{ok, {SupFlags, LoadServers}}.

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

@@ -0,0 +1,76 @@
+-module (pm_packager).
+-compile(export_all).
+-behaviour(application).
+
+%% Application callbacks
+-export([start/2, stop/1]).
+
+start() ->
+	start("", "").
+%%====================================================================
+%% Application callbacks
+%%====================================================================
+%%--------------------------------------------------------------------
+%% Function: start(Type, StartArgs) -> {ok, Pid} |
+%%                                     {ok, Pid, State} |
+%%                                     {error, Reason}
+%% Description: This function is called whenever an application
+%% is started using application:start/1,2, and should start the processes
+%% of the application. If the application is structured according to the
+%% OTP design principles as a supervision tree, this means starting the
+%% top supervisor of the tree.
+%%--------------------------------------------------------------------
+start(_, _) ->
+	recompile_scripts("0.1").
+
+%%--------------------------------------------------------------------
+%% Function: stop(State) -> void()
+%% Description: This function is called whenever an application
+%% has stopped. It is intended to be the opposite of Module:start/2 and
+%% should do any necessary cleaning up. The return value is ignored.
+%%--------------------------------------------------------------------
+stop(_State) ->
+  ok.
+
+%%====================================================================
+%% Internal functions
+%%====================================================================
+
+gen_rel(Name, Vers) ->
+		RelName = lists:append(["pm_",Name,"_rel-",Vers]),
+    F = lists:append(["{release, {\"",Name,"\",\"",Vers,"\"}, ",
+                      "{erts,\"",erlang:system_info(version),"\"},"
+                      "[{kernel,\"",get_vsn(kernel),"\"},",
+                      "{stdlib,\"",get_vsn(stdlib),"\"},",
+                      "{inets,\"",get_vsn(inets),"\"},",
+                      "{crypto,\"",get_vsn(crypto),"\"},",
+                      "{sasl,\"",get_vsn(sasl),"\"},",
+                      "{",Name,",\"",Vers,"\"}]}."]),
+	file:write_file( lists:append(["ebin/", RelName, ".rel"]),F).
+
+% Recompiles the boot scripts
+recompile_scripts(Vers) ->
+	gen_rel("master", Vers),
+	gen_rel("node", Vers),
+	gen_rel("client", Vers),
+	systools:make_script("pm_node_rel-"++Vers, [local,{path,["ebin"]}]),
+	systools:make_script("pm_master_rel-"++Vers, [local,{path,["ebin"]}]),
+	systools:make_script("pm_client_rel-"++Vers, [local,{path,["ebin"]}]).
+
+package_scripts(Vers) ->
+	systools:make_tar("ebin/pm_node_rel-"++Vers),
+	systools:make_tar("ebin/pm_client_rel-"++Vers),
+	systools:make_tar("ebin/pm_master_rel-"++Vers).
+
+get_vsn(Module) ->
+    AppFile = code:lib_dir(Module)++"/ebin/"++atom_to_list(Module)++".app",
+    {ok,[{application,_App,Attrs}]} = file:consult(AppFile),
+    {value,{vsn,Vsn}} = lists:keysearch(vsn,1,Attrs),
+    Vsn.
+
+install_messenger(Vers) ->
+	Root = code:root_dir(),
+	io:format("~p root: "++Root, [Vers]),
+	ok.
+
+% Tests

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

@@ -0,0 +1,213 @@
+% 
+%  pm_spawner.erl
+%  Spawn a process in this gen_server remotely
+%  	and hear back from it when it's got stuff to say
+%  
+%  Created by Ari Lerner on 2008-12-05.
+%  Copyright 2008 CitrusByte. All rights reserved.
+% 
+-module (pm_spawner).
+-behaviour(gen_server).
+
+-include_lib("../include/defines.hrl").
+
+%% API
+-export([start_link/0]).
+-export ([run_command/1, run_command/2, check_command/1]).
+
+%% gen_server callbacks
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).
+
+-record(state, { 
+		processes = ?DICT:new() % Array of the output
+	}).
+-define(SERVER, ?MODULE).
+
+%%--------------------------------------------------------------------
+%% 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([]) ->
+	% process_flag(trap_exit, true),
+  {ok, #state{
+		processes = ?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_call({run_command, Cmds}, _From, State) ->
+	{ok, NewState} = run_command(Cmds, State),
+	?TRACE("storing into state from call", [Cmds, NewState]),
+	{reply, ok, NewState};
+handle_call({check_command, Cmd}, _From, State) ->
+	AtomCommand = erlang:list_to_atom(Cmd),
+	?TRACE("is_key for ", [AtomCommand, ?DICT:is_key(AtomCommand, State#state.processes)]),
+	case ?DICT:is_key(AtomCommand, State#state.processes) of
+		false -> 
+			Reply = nil,
+			NewState = State;
+		true ->
+			Pid = ?DICT:fetch(AtomCommand, State#state.processes),
+			case erlang:is_pid(Pid) of
+				true ->
+					Pid ! {self(), collect},
+					receive
+						{command_response, OutFromCommand} -> 					
+							Reply = OutFromCommand,
+							NewState = State#state{processes = ?DICT:store(AtomCommand, OutFromCommand, State#state.processes)};
+						Msg ->
+							NewState = State,
+							Reply = Msg
+					after 
+						1000 -> 
+							Pid ! {self(), collect},
+							NewState = State,
+							Reply = "no output"
+					end;
+				false ->
+					NewState = State,
+					Reply = Pid
+			end
+	end,
+	{reply, Reply, NewState};
+handle_call(_Request, _From, State) ->
+	Reply = ok,
+	{reply, Reply, State}.
+%%--------------------------------------------------------------------
+%% Function: handle_cast(Msg, State) -> {noreply, State} |
+%%                                      {noreply, State, Timeout} |
+%%                                      {stop, Reason, State}
+%% Description: Handling cast messages
+%%--------------------------------------------------------------------
+handle_cast({run_command, Cmd}, State) ->
+	{ok, NewState} = run_command(Cmd, State),
+	{noreply, NewState};
+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}.
+
+% Quick helper for running commands
+run_command(Cmd) -> gen_server:call(server_location(), {run_command, Cmd}).
+check_command(Cmd) -> 
+	Command = lists:flatten(io_lib:format("~s", [Cmd])),
+	gen_server:call(server_location(), {check_command, Command}).
+
+% Run the command, start up the 
+run_command(Cmd, State) ->
+	Command = lists:flatten(io_lib:format("~s", [Cmd])),
+	AtomCommand = erlang:list_to_atom(Command),
+	Pid = spawn(fun() -> spawn_command(Command) end),
+	Storage = Pid,
+	?TRACE("storing into state", [AtomCommand]),
+	NewState = State#state{processes = ?DICT:store(AtomCommand, Storage, State#state.processes)},
+	{ok, NewState}.
+
+spawn_command(Command) ->
+	Port = erlang:open_port({spawn, Command}, [stream, exit_status, stderr_to_stdout, use_stdio]),
+	ResponsePid = response_reader(Port),
+	spawn_command_loop(Command, Port, ResponsePid).
+	
+spawn_command_loop(Command, Port, Responses) ->
+	receive
+		{Pid, collect} ->
+			case erlang:is_pid(Responses) of
+				true ->
+					io:format("There is no output on your command yet, try again in a few seconds ~p~n", [Responses]),
+					spawn_command_loop(Command, Port, Responses);
+				false ->
+					Pid ! {command_response, Responses}
+			end;
+		{exit_status, _} -> 
+			spawn_command_loop(Command, Port, Responses);
+		{done, Port, Response} ->			
+			?TRACE("Received done message", Response),
+			spawn_command_loop(Command, Port, Response);
+	  {Port, {exit_status, 0}} ->			
+			?TRACE("Received exit_status", [Port]),
+			Responses ! {Port, {exit_status, 0, self()}},
+			receive
+				{ok, Resp} ->
+					?TRACE("Received ok back", [Resp]),
+					spawn_command_loop(Command, Port, Resp)
+			end;
+		Mes ->
+			?TRACE("received message", [Mes]),
+			Responses ! Mes,
+			spawn_command_loop(Command, Port, Responses)
+	end.
+
+response_reader(Port) -> 
+	ResponsePid = spawn(fun() -> response_reader_loop(Port, []) end),
+	ResponsePid.
+	
+response_reader_loop(Port, Acc) ->
+	receive
+		{Port, {data, Bin}} ->
+			?TRACE("received data", [Bin]),
+			response_reader_loop(Port, [Bin|Acc]);
+    {Port, {exit_status, 0, Pid}} ->			
+      catch erlang:port_close(Port),
+      Response = lists:flatten(lists:reverse(Acc)),
+			?TRACE("received exit_status", [Response, Port]),
+			Pid ! {ok, Response};
+    {Port, {exit_status, _}} ->
+      catch erlang:port_close(Port),
+      Output = lists:flatten(lists:reverse(Acc)),
+			{error, Output};
+		{Pid, get_data} ->
+			?TRACE("get_data for", [Pid, Acc]),
+			Pid ! {data, Port, Acc},			
+			response_reader_loop(Port, Acc);
+		{_, collect} ->
+			response_reader_loop(Port, Acc);
+		Mes ->
+			io:format("Unexpected message in response_reader_loop ~p~n", [Mes]),
+			response_reader_loop(Port, Acc)
+	end.
+
+server_location() -> global:whereis_name(?SERVER).

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

@@ -0,0 +1,11 @@
+-module (pm_strings).
+-include_lib("../include/defines.hrl").
+-compile(export_all).
+
+string_join(Items, Sep) ->
+    lists:flatten(lists:reverse(string_join1(Items, Sep, []))).
+
+string_join1([Head | []], _Sep, Acc) ->
+    [Head | Acc];
+string_join1([Head | Tail], Sep, Acc) ->
+    string_join1(Tail, Sep, [Sep, Head | Acc]).

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

@@ -0,0 +1,72 @@
+-module (utils).
+-include_lib("../include/defines.hrl").
+-compile(export_all).
+
+-ifdef(EUNIT).
+-include_lib("eunit/include/eunit.hrl").
+-endif.
+
+% Turn a list from
+% [{"0.66"}, {"0.32"}, []] -> [0.66, 0.32]
+convert_responses_to_int_list(L) ->
+	Sum = lists:foldr( fun(Int, Sum) -> Int + Sum end, 0, [erlang:list_to_float(F) || {F} <- L] ),
+	average_for_list(Sum, L).
+
+% Start a timer to fire off Fun after Time number of milliseconds
+start_timer(Name, Time, Fun) ->
+	case whereis(Name) of
+		undefined -> register(Name, spawn(fun() -> tick_timer(Time, Fun) end));
+		_ -> ok
+	end.
+start_timer(Time, Fun) -> 
+	start_timer(?MODULE, Time, Fun).
+	% register(?MODULE, spawn(fun() -> tick_timer(Time, Fun) end)). 
+
+stop_timer(Name) -> erlang:whereis(Name) ! stop.
+stop_timer() -> ?MODULE ! stop. 
+
+
+tick_timer(Time, Fun) -> 
+	receive 
+		stop -> void 
+	after Time -> 
+		Fun(), 
+		tick_timer(Time, Fun)
+	end. 
+
+average_of_list(L) ->
+	Sum = lists:foldr( fun(Int, Sum) -> 
+		case erlang:is_float(Int) of
+			true -> Integer = Int;
+			false -> Integer = erlang:list_to_float(Int)
+		end,
+		Integer + Sum 
+	end, 0, [F || F <- L] ),
+	average_for_list(Sum, L).
+
+% Get the average of the list
+average_for_list(Num, L) ->
+	case length(L) of
+		0 ->
+			-1;
+		_ ->
+			Num / length(L)
+	end.
+
+
+
+% Provisioning utils
+distribute_modules_to(Modules, Nodes) ->
+	% transfer the modules to all the nodes
+	lists:foreach(fun(Node) ->
+			transfer_modules(Node, Modules)
+	end, Nodes).
+
+% Transfer modules of code to this node
+transfer_modules(Node, Modules) ->
+	[transfer_module(Node, M) || M <- Modules].
+
+% Transfer one module to the Node
+transfer_module(Node, Module) ->
+	{_Module, Binary, Filename} = code:get_object_code(Module),
+	rpc:call(Node, code, load_binary, [Module, Filename, Binary]).

data/lib/erlang/messenger/useful_snippets

@@ -0,0 +1,17 @@
+% Snippets
+% lists:map(fun(No) -> net_adm:ping(No) end, pm_cluster:any_new_servers()).
+
+% Start test nodes, defining testing
+% erl -pa ./ebin -kernel inet_dist_listen_min 7000 inet_dist_listen_max 7050 -setcookie poolparty -boot pm_node_rel-0.1 -sname node0
+% erl -pa ./ebin -kernel inet_dist_listen_min 7000 inet_dist_listen_max 7050 -setcookie poolparty -boot pm_node_rel-0.1 -sname node1
+
+% Starting the client on the master
+% erl -pa /var/lib/gems/1.8/gems/poolparty-0.2.54/lib/erlang/messenger/ebin -kernel inet_dist_listen_min 7000 inet_dist_listen_max 7050 -sname client -setcookie poolparty -run pm_client start
+
+% Get the load
+% erl -pa /var/lib/gems/1.8/gems/poolparty-0.2.46/lib/erlang/messenger/ebin -kernel inet_dist_listen_min 7000 inet_dist_listen_max 7050 -sname client -setcookie poolparty -run pm_client start
+
+% cd /var/poolparty && gem uninstall poolparty && wget http://github.com/auser/poolparty/tree/master%2Fpkg%2Fpoolparty.gem?raw=true -O poolparty.gem 2>&1 && gem install --no-ri --no-rdoc poolparty.gem
+
+% LOAD TESTING
+% ab -n 10000 -c 5 http://75.101.162.232/