poolparty 0.2.6 → 0.2.18

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

@@ -0,0 +1,124 @@
+%%%-------------------------------------------------------------------
+%%% 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).
+
+%% 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).
+
+% Client function definitions
+-export ([stop/0]).
+-export ([get_load_for_type/1, fire_cmd/1, run_reconfig/0]).
+
+%%====================================================================
+%% API
+%%====================================================================
+%%--------------------------------------------------------------------
+%% 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() ->
+	utils:start_timer(10000, fun() -> net_adm:ping(master) end),
+  gen_server:start_link({global, ?SERVER}, ?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{}}.
+
+%%--------------------------------------------------------------------
+%% 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(_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(_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}.
+
+%%--------------------------------------------------------------------
+%%% Internal functions
+%%--------------------------------------------------------------------
+
+% Get the load for the type sent...
+get_load_for_type(Type) ->
+	String = string:concat(". /etc/profile && server-get-load -m ",Type),
+	{os:cmd(String)}.
+
+% Rerun the configuration
+run_reconfig() ->	{os:cmd(". /etc/profile && server-rerun")}.
+
+% Allows us to fire off any command (allowed by poolparty on the check)
+fire_cmd(Cmd) ->
+	String = ". /etc/profile && server-fire-cmd \""++Cmd++"\"",
+	{os:cmd(String)}.
+
+% Stop the pm_node entirely
+stop() ->
+	gen_server:cast(?MODULE, stop).

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

@@ -0,0 +1,40 @@
+% This supervisor is responsible for monitoring the 
+% client service
+
+-module (pm_node_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 = 3, % 1000
+	MaxTimeBetRestarts = 30, % 3600
+
+	SupFlags = {RestartStrategy, MaxRestarts, MaxTimeBetRestarts},
+
+	LoadServers = [
+		{pm_node1,
+			{pm_node, start_link, []}, 
+			permanent, 5000, worker, 
+			[pm_node]
+		}
+	],
+
+	{ok, {SupFlags, LoadServers}}.

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

@@ -0,0 +1,73 @@
+-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(_Type, _) ->
+	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),
+	systools:make_script("pm_node_rel-"++Vers, [local,{path,["ebin"]}]),
+	systools:make_script("pm_master_rel-"++Vers, [local,{path,["ebin"]}]).
+
+package_scripts(Vers) ->
+	systools:make_tar("ebin/pm_node_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/utils.erl

@@ -0,0 +1,38 @@
+-module (utils).
+-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(Time, Fun) -> 
+	register(?MODULE, spawn(fun() -> tick_timer(Time, Fun) end)). 
+
+stop_timer() -> ?MODULE ! stop. 
+
+tick_timer(Time, Fun) -> 
+	receive 
+		stop -> 
+			void 
+	after Time -> 
+		Fun(), 
+		tick_timer(Time, Fun) 
+end. 
+
+
+% Private
+% Get the average of the list
+average_for_list(Num, L) ->
+	case length(L) of
+		0 ->
+			0;
+		_ ->
+			Num / length(L)
+	end.

data/lib/poolparty/base_packages/haproxy.rb

@@ -21,8 +21,15 @@ module PoolParty
 
           # Tempalte variables
           variable(:name => "name_haproxy", :value => "#{@parent.name}")
-          variable(:name => "nodenames_haproxy", :value => list_of_node_names)
-          variable(:name => "node_ips_haproxy",  :value => list_of_node_ips)
+          
+          if @parent.provisioning?
+            variable(:name => "nodenames_haproxy", :value => "#{list_of_running_instances.map{|a| "#{a.send :name}" }.join("\t")}")
+            variable(:name => "node_ips_haproxy",  :value => "#{list_of_running_instances.map{|a| "#{a.send :ip}" }.join("\t")}")
+          else
+            variable(:name => "nodenames_haproxy", :value => "generate('/usr/bin/env', '/var/lib/gems/1.8/bin/server-list-active', '-c', 'name')")
+            variable(:name => "node_ips_haproxy",  :value => "generate('/usr/bin/env', '/var/lib/gems/1.8/bin/server-list-active', '-c', 'ip')")
+          end
+          
           variable(:name => "ports_haproxy", :value => ([(self.respond_to?(:port) ? port : Base.port)].flatten))        
           variable(:name => "forwarding_port", :value => (respond_to?(:forwarding_port) ? forwarding_port : Base.forwarding_port))
           variable(:name => "proxy_mode", :value => (respond_to?(:proxy_mode) ? proxy_mode : Base.proxy_mode))

data/lib/poolparty/base_packages/heartbeat.rb

@@ -4,38 +4,50 @@ module PoolParty
       
       def enable
         execute_if("$hostname", "master") do
-          has_package(:name => "heartbeat-2", :ensure => "installed")
-          has_service(:name => "heartbeat", :hasstatus => true) do
-            ensures "running"
-          end
+          has_package(:name => "heartbeat-2", :ensure => "installed") do
+            # These can also be passed in via hash
+            has_remotefile(:name => "/etc/ha.d/ha.cf") do
+              mode 444
+              notify 'Service["heartbeat"]'
+              template File.join(File.dirname(__FILE__), "..", "templates/ha.cf")
+            end
+
+            has_remotefile(:name => "/etc/ha.d/authkeys") do
+              mode 400
+              notify 'Service["heartbeat"]'
+              template File.join(File.dirname(__FILE__), "..", "templates/authkeys")
+            end
+
+            has_remotefile(:name => "/etc/ha.d/cib.xml") do
+              mode 444
+              notify 'Exec["heartbeat-update-cib"]'
+              template File.join(File.dirname(__FILE__), "..", "templates/cib.xml")
+            end
+            
+            has_service(:name => "heartbeat", :hasstatus => true)
+          end          
         
           has_exec(:name => "heartbeat-update-cib", :command => "/usr/sbin/cibadmin -R -x /etc/ha.d/cib.xml", :refreshonly => true)
-        
-          # variables for the templates
-          has_variable({:name => "ha_nodenames", :value => list_of_node_names})
-          has_variable({:name => "ha_node_ips",  :value => list_of_node_ips})
-          has_variable({:name => "ha_port", :value => (self.respond_to?(:port) ? port : Base.port)})
-        
-          # These can also be passed in via hash
-          has_remotefile(:name => "/etc/ha.d/ha.cf") do
-            mode 444
-            requires 'Package["heartbeat-2"]'
-            notify 'Service["heartbeat"]'
-            template File.join(File.dirname(__FILE__), "..", "templates/ha.cf")
-          end
-        
-          has_remotefile(:name => "/etc/ha.d/authkeys") do
-            mode 400
-            requires 'Package["heartbeat-2"]'
-            notify 'Service["heartbeat"]'
-            template File.join(File.dirname(__FILE__), "..", "templates/authkeys")
+          
+          if @parent.provisioning?
+            variable(:name => "ha_nodenames", :value => "#{list_of_running_instances.map{|a| "#{a.send :name}" }.join("\t")}")
+            variable(:name => "ha_node_ips",  :value => "#{list_of_running_instances.map{|a| "#{a.send :ip}" }.join("\t")}")
+          else
+            # variables for the templates
+            variable(:name => "ha_nodenames", :value => "generate('/usr/bin/env', '/var/lib/gems/1.8/bin/server-list-active', '-c', 'name')")
+            variable(:name => "ha_node_ips",  :value => "generate('/usr/bin/env', '/var/lib/gems/1.8/bin/server-list-active', '-c', 'ip')")
           end
+          
+          has_variable({:name => "ha_timeout",  :value => (self.respond_to?(:timeout) ? timeout : "5s")})
+          has_variable({:name => "ha_port", :value => (self.respond_to?(:port) ? port : Base.port)})
+          
+        end
         
-          has_remotefile(:name => "/etc/ha.d/cib.xml") do
-            mode 444
-            requires 'Package["heartbeat-2"]'
-            notify 'Exec["heartbeat-update-cib"]'
-            template File.join(File.dirname(__FILE__), "..", "templates/cib.xml")
+        execute_if("$hostname", "master") do
+          if list_of_node_names.size > 1
+            has_exec(:name => "update pem for heartbeat", :refreshonly => true) do
+              command "scp /etc/puppet/ssl/ca/ca_crl.pem #{user || Base.user}@#{list_of_node_ips[1]}:/etc/puppet/ssl/ca"
+            end
           end
         end
         

data/lib/poolparty/base_packages/poolparty.rb

@@ -4,29 +4,52 @@ module PoolParty
       
       def enable        
         has_package(:name => "erlang")
-        # These should be installed automagically by poolparty, but just in case
-        with_options(:requires => 'Package["update-rubygems"]') do
-          has_gempackage(:name => "open4")
-          has_gempackage(:name => "parsetree")
-          has_gempackage(:name => "rubyinline")
-          has_gempackage(:name => "activesupport")
+        has_package(:name => "erlang-dev")
+        has_package(:name => "erlang-src")
+        
+        has_package(:name => "rubygems") do
+          # These should be installed automagically by poolparty, but just in case
+          # TODO: Fix the requires method with a helper          
           has_gempackage(:name => "logging")
-          has_gempackage(:name => "hoe")
-          has_gempackage(:name => "xml-simple")
-          has_gempackage(:name => "ruby2ruby")
-
-          has_gempackage(:name => "grempe-amazon-ec2", :source => "http://gems.github.com", :requires => 'Package["xml-simple"]')
-          has_gempackage(:name => "auser-poolparty", :source => "http://gems.github.com", :requires => 'Package["activesupport", "logging", "hoe", "open4"]')          
-        end                
+          has_gempackage(:name => "xml-simple") do
+            has_gempackage(:name => "grempe-amazon-ec2", :source => "http://gems.github.com")
+          end
+          has_gempackage(:name => "rake")
+          
+          has_gempackage(:name => "hoe") do
+            has_gempackage(:name => "open4")
+            
+            has_gempackage(:name => "ParseTree", :version => "2.2.0") do
+              has_gempackage(:name => "ruby2ruby")
+              has_gempackage(:name => "activesupport") do
+                has_gempackage(:name => "auser-poolparty", :source => "http://gems.github.com") do
+                  has_exec(:name => "build_messenger", :command => ". /etc/profile && server-build-messenger")
+                  has_exec(:name => "start_node", :command => ". /etc/profile && server-start-node", :requires => 'Exec["build_messenger"]')
+                end
+              end
+              has_gempackage(:name => "RubyInline")
+            end
+          end          
+          
+        end
+                
         # Build hostsfile
         # TODO: COME BACK AND CLEAN THIS UP
         (self.respond_to?(:list_of_running_instances) ? self : parent).list_of_running_instances.each do |ri|
           has_host({:name => "#{ri.name}", :ip => ri.ip })
         end
         
-        cron({:command => "cloud-maintain"}) do
-          minute "*/5"
-          user "puppet"
+        # Custom run puppet to minimize footprint
+        # TODO: Update the offsetted times
+        has_cron(:name => "puppetd runner", :user => Base.user, :minute => [0,15,30,45]) do
+          command((self.respond_to?(:master) ? self : parent).master.puppet_runner_command)
+        end
+        
+        # These are all requirements on the master
+        execute_if("$hostname", "master") do
+          has_cron({:command => ". /etc/profile && which cloud-maintain | /bin/sh", :minute => "*/3"})
+          # TODO: Update this so it only runs when needed
+          has_exec(:name => ". /etc/profile && server-start-master")
         end
         # has_host(:name => "puppet", :ip => (self.respond_to?(:master) ? self : parent).master.ip)
       end

data/lib/poolparty/base_packages/ruby.rb

@@ -10,10 +10,9 @@ module PoolParty
         has_package(:name => "libreadline-ruby1.8")
         has_package(:name => "libruby1.8")                
         has_package(:name => "ruby1.8-dev")
-        has_package(:name => "ruby1.8")
-        has_package(:name => "rubygems")
+        has_package(:name => "ruby1.8")        
         
-        has_line_in_file("export PATH=$PATH:/var/lib/gems/1.8/bin/", "/etc/profile")
+        has_line_in_file("export PATH=$PATH:/var/lib/gems/1.8/bin:/sbin", "/etc/profile")
         
         # exec(:name => "update-rubygems") do
         #   command "gem update --system"

data/lib/poolparty/config/allowed_commands.yml

@@ -0,0 +1 @@
+echo 'hello world' > test.del.txt

data/lib/poolparty/core/array.rb

@@ -15,10 +15,13 @@ class Array
   def nice_runnable(quiet=true)
     self.flatten.reject{|e| (e.nil? || e.empty?) }.join(" \n ").chomp.nice_runnable(quiet)
   end
-  def to_string(prev="")
-    map {|a| a.to_string(prev)}.join("\n")
+  def to_string(pre="")
+    map {|a| a.to_string(pre)}.join("\n")
   end
   def get_named(str="")
     map {|a| a.name == str ? a : nil }.reject {|a| a.nil? }
   end
+  def to_option_string(ns=[])
+    "[ #{map {|e| e.to_option_string }.join(", ")} ]"
+  end
 end

data/lib/poolparty/core/hash.rb

@@ -12,14 +12,28 @@ class Hash
     o.keys.each {|k| self.delete(k) }
     o
   end
+  def append(other_hash)
+    returning Hash.new do |h|
+      h.merge!(self)
+      other_hash.each do |k,v|
+        h[k] = has_key?(k) ? [self[k], v].flatten : v
+      end
+    end
+  end
+  def append!(other_hash)
+    other_hash.each do |k,v|
+      self[k] = has_key?(k) ? [self[k], v].flatten : v
+    end
+    self
+  end
   def safe_merge(other_hash)
     merge(other_hash.delete_if {|k,v| has_key?(k) })
   end
   def safe_merge!(other_hash)
     merge!(other_hash.delete_if {|k,v| has_key?(k) && !v.nil? })
   end
-  def flush_out(prev="", post="")
-    map {|k,v| "#{prev}#{k} => #{v.to_option_string}#{post}"}
+  def flush_out(pre="", post="")
+    map {|k,v| "#{pre}#{k} => #{v.to_option_string}#{post}"}
   end
   def to_os
     m={}

data/lib/poolparty/core/string.rb

@@ -25,15 +25,22 @@ class String
     self.split("::")[-1].downcase rescue self
   end
   def sanitize
-    self.gsub(/[\.]*/, '')
+    self.gsub(/[\.\/]*/, '')
   end
   def nice_runnable(quite=true)
     self.split(/ && /).join("\n")
   end
+  # This is the method we use to turn the options into a string to build the main 
+  # manifests
   def to_option_string(ns=[])
     a_template = (self =~ /template/) == 0
     a_service = self =~ /^[A-Z][a-zA-Z]*\[[a-zA-Z0-9\-\.\"\'_\$\{\}\/]*\]/
-    (a_service || a_template) ? "#{self}" : "'#{self}'"
+    a_function = self =~/(.)*\((.)*\)(.)*/
+    if is_a?(PoolParty::Resources::Resource)
+      self.to_s
+    else
+      (a_service || a_template || a_function) ? self : "'#{self}'"
+    end    
   end
   # Refactor this guy to get the class if the class is defined, and not always create a new one
   # although, it doesn't really matter as ruby will just reopen the class

data/lib/poolparty/core/symbol.rb

@@ -1,6 +1,6 @@
 class Symbol
-  def to_string(prev="")
-    "#{prev}#{self.to_s}"
+  def to_string(pre="")
+    "#{pre}#{self.to_s}"
   end
   def sanitize
     self.to_s.sanitize

data/lib/poolparty/dependency_resolutions/base.rb

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

data/lib/poolparty/dependency_resolutions/puppet.rb

@@ -0,0 +1,49 @@
+module PoolParty
+  module DependencyResolutions
+    module Puppet
+      
+      def pretty_print_resources(pre=" ")
+        returning Array.new do |out|
+          resources.each do |name, res|
+            out << "#{pre}#{name}"
+            out << "#{pre*2}#{res.map {|a| a.name}}"
+            res.each do |r|
+              out << "#{pre*2}#{r.pretty_print_resources(pre*2)}"
+            end
+          end
+        end.join("\n")
+      end
+      
+      # Generic to_s
+      # Most Resources won't need to extend this
+      def to_string(pre="")
+        opts = get_modified_options
+        returning Array.new do |output|
+          unless cancelled?
+            output << @prestring || ""
+          
+            if resources && !resources.empty?
+              @cp = classpackage_with_self(self)
+              output << @cp.to_string
+              output << "include #{@cp.name.sanitize}"
+            end
+            
+            unless virtual_resource?
+              output << "#{pre}#{class_type_name.downcase} {"
+              output << "#{pre}\"#{self.key}\":"
+              output << opts.flush_out("#{pre*2}").join(",\n")
+              output << "#{pre}}"            
+            end
+          
+            output << @poststring || ""
+          end
+        end.join("\n")
+      end
+      
+      def to_s
+        "#{class_type_name.capitalize}['#{key}']"
+      end
+      
+    end
+  end
+end

data/lib/poolparty/exceptions/UnacceptableCommand.rb

@@ -0,0 +1,5 @@
+class UnacceptableCommand < Exception  
+  def initialize(msg="Unacceptable command")
+    @message = "Disallowed or unacceptable command error: #{msg}"
+  end
+end

data/lib/poolparty/helpers/console.rb

@@ -7,8 +7,9 @@ module PoolParty
     
     # Load a file that contains a pool into memory
     def load_pool(filename)
-      unless filename && ::File.file?(filename)
-        puts "Could not load pool"
+      filename = filename.chomp
+      unless filename && ::File.readable?(filename)
+        puts "Could not load pool: #{filename}"
         exit
       else
         PoolParty::Script.inflate(open(filename).read, File.dirname(filename))

data/lib/poolparty/helpers/display.rb

@@ -7,10 +7,10 @@ module PoolParty
           print v.pretty_print
         end
       else
-        prev = "\t"
+        pre = "\t"
         clouds.each do |name, cl|
-          puts cl.pretty_name(prev*2, cl)
-          puts cl.pretty_options(prev*2, cl) #cl.pretty_print("#{prev}\t")
+          puts cl.pretty_name(pre*2, cl)
+          puts cl.pretty_options(pre*2, cl) #cl.pretty_print("#{pre}\t")
         end
       end