poolparty 0.2.84 → 1.2.2

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

@@ -1,200 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% 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 -m ",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

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

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

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

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

@@ -1,73 +0,0 @@
--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
-	io:format("Sending ~p to ~p~n", [Modules, 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

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

data/lib/poolparty/capistrano.rb

@@ -1,18 +0,0 @@
-module PoolParty
-  module Capistrano
-    
-    def set_cloud(cld=nil)
-      raise unless cld
-      @cloud = cld
-    end
-    
-    def set_poolparty_roles
-      returning Array.new do |arr|
-        arr << "role 'master.#{@cloud.name}'.to_sym, '#{@cloud.master.ip}'"
-        arr << "role :master, '#{@cloud.master.ip}'"
-        arr << "role :slaves, '#{@cloud.nonmaster_nonterminated_instances.map{|a| a.ip}.join('", "')}'" if @cloud.nonmaster_nonterminated_instances.size > 0
-      end.join("\n")
-    end
-    
-  end
-end

data/lib/poolparty/config/postlaunchmessage.txt

@@ -1,5 +0,0 @@
-Your cloud is launching
------------------------
-Your master's ip address is: :master_ip
-
-Depending on how your cloud is setup, this process may take a while.

data/lib/poolparty/dependency_resolutions/base.rb

@@ -1,12 +0,0 @@
-module PoolParty
-  module DependencyResolutions
-    module Base
-      
-      def to_s
-      end
-      def to_string        
-      end
-      
-    end
-  end
-end