auser-poolparty 1.2.0 → 1.2.1

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :minor: 2
-:patch: 0
+:patch: 1
 :major: 1

data/bin/cloud-verify

@@ -23,6 +23,8 @@ o.loaded_clouds.each do |cld|
       Verification failed: #{e}"
         Please check your clouds.rb for any errors
 
+      Exception: #{e.class}: #{e.message}\n\t#{e.backtrace.join("\n\t")}
+
       EOM
   end
 

data/bin/install-poolparty

@@ -0,0 +1,216 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolpartycl"
+require "highline/import"
+     
+welcome_msg = <<-EOE
+We are going to take you through the installation process of PoolParty.
+
+First, we'll setup your environment so using PoolParty will be a breeze
+EOE
+
+closing_message = <<-EOE
+You are now set to ride the waves with PoolParty! You'll notice there is a clouds.rb file in your current directory. You can start your new cloud
+by typing:
+
+cloud start
+
+You can start your clouds.rb. More samples are available here: 
+  http://github.com/auser/poolparty-examples/tree/master
+EOE
+
+colored_say "Welcome to PoolParty!", :help
+say welcome_msg
+begin
+  t = colored_ask "Press enter to continue or Ctrl+C to exit"
+rescue Exception => e
+  say <<-EOE
+
+Cancelled PoolParty installation
+
+You can always restart this by typing:
+  install-poolparty
+EOE
+  exit 0
+end
+
+say("\nWhat remoter base would you like to use?")
+choose do |menu|
+  menu.prompt = "> "
+
+  available_bases.each do |base|
+    menu.choice base.to_sym do 
+      
+      colored_say "Great, we'll be using #{base}"
+      
+      case base
+      when :ec2
+        
+        key_help_str = <<-EOE
+Now you need to get your keys from Amazon AWS.
+If you don't already have your keys setup, navigate to http://aws.amazon.com
+and click on Your Account. Click on the Access Identifiers tab and find:
+Your Access Key ID. This is your access key.
+        EOE
+        access_key_str = <<-EOE
+Since you'll be using ec2, we'll have to set some things up before
+we can get going on PoolParty. Don't worry, this information will stay between us.
+
+        EOE
+        say access_key_str
+        ask_with_help :message => "First, what's your access key?",
+                      :help => key_help_str do |t|
+          
+          @access_key = t
+          
+        key_help_str = <<-EOE
+If you don't already have your keys setup, navigate to http://aws.amazon.com
+and click on Your Account. Click on the Access Identifiers tab and find:
+Your Secret Access Key ID. Click on the - show button.
+This is your secret access key.
+        EOE
+          ask_with_help :message => "Awesome. Now what's your secret access key? ",
+                        :help => key_help_str do |t|
+            @secret_access_key = t
+            
+            rescued_ask_str = <<-EOS
+Super duper! You'll need to make sure you have yout X.509 certificate downloaded too.
+Save this in your ~/.ec2 directory.
+
+Press enter when you're ready
+EOS
+
+            cert_help_str = <<-EOE
+To get your X.509 certificates, navigate to http://aws.amazon.com and login. Click on
+Your Account and scroll down. The X.509 Certificate box is at the bottom. Make sure you
+click download and save the cert-*.pem file. If you don't know or don't have the pk-*.pem file
+you may have to recreate it. Not to worry though, it's super easy. Click on the Create New button. 
+From there, you can download the cert-*.pem and the pk-*.pem files.
+
+            EOE
+
+            ask_with_help :message => rescued_ask_str,
+                          :help => cert_help_str do |t|
+
+begin
+  ec2 = PoolParty::Remote::Ec2.ec2({:access_key => @access_key, :secret_access_key => @secret_access_key})
+  keypairs = ec2.describe_keypairs["keySet"]["item"]
+  keynames = keypairs.map {|k| k["keyName"]}  
+rescue Exception => e
+  colored_say "There was an error: #{e}. Recheck your access_key and secret_access_key to make sure you copied them correctly"
+  exit 1
+end
+
+key_str =<<-EOK
+
+Finally, what's the name of the keypair you'd like to use?
+
+You already have the following keypairs setup:
+\t#{keynames.join("\n\t")}
+
+You can use one of these keys, or create a new one.
+EOK
+
+key_str_help =<<-EOH
+  To make a new keypair, make sure you have the ec2 tools installed. You can create a new one by typing the command:
+    ec2-add-keypair
+  
+  Save this into a file in your ~/.ec2 directory. Enter the name of the keypair here.
+EOH
+            ask_with_help :message => key_str,
+                          :help => key_str_help do |t|
+                @keypair = t
+                say <<-EOE
+
+In your clouds.rb, you can use this keypair in your clouds.
+  
+Create one for each cloud you want to use.
+
+                EOE
+                
+                clds =<<-EOC
+pool :my_pool do
+  cloud :my_app do
+
+    # Copy these lines and source them in your .profile or .bashrc file
+    # export AWS_ACCESS_KEY="#{@access_key}"
+    # export AWS_SECRET_ACCESS_KEY="#{@secret_access_key}"
+    # export EC2_PRIVATE_KEY=$(ls ~/.ec2/pk-*.pem)
+    # export EC2_CERT=$(ls ~/.ec2/cert-*.pem)
+
+    access_key "#{@access_key}"
+    secret_access_key "#{@secret_access_key}"
+    keypair "#{@keypair}"
+    
+    has_file "/etc/motd" do
+      content "Welcome to your first PoolParty instance!"
+    end
+  end
+end             
+                EOC
+                
+                ::File.open("clouds.rb", "w") {|f| f << clds}
+                colored_say closing_message
+              end
+            end            
+            
+          end
+        end
+      when :vmrun
+        vmrun_file_help =<<-EOV
+Vmware uses a vmwarevm file to keep information about the vmware instance. To find the vmwarevm file, 
+navigate to vmware and find the vm you'd like to use. Find this in finder and paste that here.
+        EOV
+        default_vmrun_file = Dir["#{::File.expand_path("~")}/Documents/Virtual\ Machines/*.vmwarevm"].first rescue nil
+        vmrun_file = <<-EOE
+Awesome. What's the path to your vmwarevm file?
+#{
+if default_vmrun_file
+ "Is this it: #{default_vmrun_file}? (Press enter to accept default)" 
+end
+}
+        EOE
+        ask_with_help :message => vmrun_file,
+                      :help => vmrun_file_help do |t|
+          
+          t = default_vmrun_file if t.nil? || t.empty?
+          ip_help =<<-EOV
+Right now, vmrun, the remoter base needs an explicitly set ip. Log into your vm and type ifconfig. Copy and paste that here.
+          EOV
+          ask_with_help :message => "Now, what's the ip of your vm?",
+                        :validate => /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|h|H/,
+                        :help => ip_help do |i|
+           
+           ask_with_help :message => "Finally, make sure you get your key on the vm. You can use this command: \n\tscp ~/.ssh/id_rsa.pub root@#{i}:/root/.ssh/authorized_keys.\n\nPress enter when you're ready" do |qqqq|
+             
+          vmx_file = Dir["#{t}/*.vmx"].first
+                clds =<<-EOC
+pool :my_pool do
+  cloud :my_app do
+    using :vmrun do
+      vmx_hash({
+        "#{vmx_file}" => "#{i}"
+      })
+    end
+      
+    has_file "/etc/motd" do
+      content "Welcome to your first PoolParty instance!"
+    end
+  end
+end             
+                EOC
+
+                ::File.open("clouds.rb", "w") {|f| f << clds}
+                colored_say closing_message
+                
+              end
+            end
+          end
+      else
+        say("Not sure what remoter_base you mean. Please choose from the menu.")
+      end      
+    end
+  end
+  
+end

data/lib/poolparty/core/string.rb

@@ -176,5 +176,16 @@ class String
   def macify
     split(":").map {|a| a[0].chr == "0" ? a[1].chr : a}.join(":")
   end
+
+  ##
+  # @param o<String> The path component to join with the string.
+  #
+  # @return <String> The original path concatenated with o.
+  #
+  # @example
+  #   "merb"/"core_ext" #=> "merb/core_ext"
+  def /(o)
+    File.join(self, o.to_s)
+  end
   
 end

data/lib/poolparty/core/symbol.rb

@@ -14,4 +14,14 @@ class Symbol
   def <=>(b)
     "#{self}" <=> "#{b}"
   end
+  ##
+  # @param o<String, Symbol> The path component to join with the string.
+  #
+  # @return <String> The original path concatenated with o.
+  #
+  # @example
+  #   :merb/"core_ext" #=> "merb/core_ext"
+  def /(o)
+    File.join(self.to_s, o.to_s)
+  end
 end

data/lib/poolparty/dependency_resolver/chef_resolver.rb

@@ -39,11 +39,7 @@ module PoolParty
     
     def comp(cld_name, props, tabs)
       
-      default_recipe = [ 
-        resources_to_string(props[:resources],tabs),
-        services_to_string(props[:services],tabs)
-      ].join("\n")
-
+      default_recipe = resources_to_string(props[:resources],tabs)
       ::File.open("#{base_dir}/recipes/default.rb", "w+") {|f| f << default_recipe }
       
       default_recipe
@@ -73,7 +69,7 @@ module PoolParty
     end
     
     def resources_to_string(opts,tabs=0)
-      out = []        
+      out = []
       out << opts.map do |resource|
         case ty = resource.delete(:pp_type)
         when "variable"
@@ -82,6 +78,8 @@ module PoolParty
           "#{tf(tabs)}include_recipe #{to_option_string(resource.name)}"
         when "chef_library"
           "#{tf(tabs)}require #{to_option_string("/etc/chef/lib/#{resource.name}")}"
+        when "plugin"
+          handle_print_service(resource, tabs)
         else
           real_type = handle_chef_types(ty)
           real_name = resource[:name]
@@ -89,22 +87,22 @@ module PoolParty
           "#{tf(tabs)}#{real_type} \"#{real_name}\" do\n#{tf(tabs+1)}#{hash_flush_out(res).compact.join("\n#{tf(tabs+1)}")}\n#{tf(tabs)}end"
         end
       end      
-      out.join("\n")
+      out.compact.join("\n")
     end
     
     def handle_print_variable(varhash)
       o = []
       if varhash[:namespace]
         o << ["\n#{varhash[:namespace]} Mash.new unless attribute?('#{varhash[:namespace]}')"]
-        o << "#{varhash[:namespace]}[:#{varhash[:name]}] = #{to_option_string(varhash[:value])}\n"
+        o << "#{varhash[:namespace]}['#{varhash[:name]}'] = #{to_option_string(varhash[:value])}\n"
       else
-        o << "poolparty[:#{varhash[:name]}] = #{to_option_string(varhash[:value])}"
+        o << "poolparty['#{varhash[:name]}'] = #{to_option_string(varhash[:value])}"
       end
       ::File.open("#{base_dir}/attributes/poolparty.rb", "a+") do |f| 
         f << o.join("\n")
         f << "\n"
       end
-      ""
+      nil
     end
         
     def handle_chef_types(ty)
@@ -137,19 +135,15 @@ module PoolParty
       end
     end
     
-    def handle_print_service(klassname, klassarray, tabs)
-      case klassname
-      when nil
-        nil
-      else
-        kname = klassname.to_s.gsub(/pool_party_/, '').gsub(/_class/, '')
+    def handle_print_service(plugin, tabs)
+      if plugin && plugin.has_key?(:resources) && !plugin[:resources].empty?
+        kname = plugin.delete(:name).to_s.gsub(/pool_party_/, '').gsub(/_class/, '')
         str = "\n#{tf(tabs)}# #{kname}\n"
         str << "#{tf(tabs)}"
-        klassarray.each do |hsh|
-          str << _compile(hsh,tabs+1, klassname)
-        end        
+        str << _compile(plugin,tabs+1, kname)
         str << "#{tf(tabs)}"
       end
+      str
     end
     
     # Check if the hash has content and that the content exists here. This is used
@@ -170,21 +164,6 @@ module PoolParty
       hsh
     end
     
-    # Turn the services into strings using the handle_print_service method
-    # Here we can strip out non-meaningful chef services
-    def services_to_string(opts,tabs=0)
-      if opts
-        str = ""
-        [:control_statements, :conditional].each do |k|
-          opts.delete(k)
-        end
-        opts.map do |klassname, klasshash|
-          str << handle_print_service(klassname, klasshash, tabs)
-        end
-        str
-      end
-    end
-    
     # Handle ensures
     def handle_actions(key,value)
       case key
@@ -197,6 +176,8 @@ module PoolParty
     
     # Take the keys from the resource hash and turn them into chef-like
     # meaningful keys. This is how helpers are created for chef
+    # 
+    # * <tt>reloads</tt> - todo
     def to_chef_key(key)
       case key
       when :ensures
@@ -224,6 +205,7 @@ module PoolParty
     
     # Resolve the value of the resource hash into a meaningful chef
     # value. Resources are turned into resource strings here
+    #
     def to_option_string(obj)
       case obj
       when PoolParty::Resources::Resource

data/lib/poolparty/dependency_resolver/dependency_resolver_cloud_extensions.rb

@@ -6,15 +6,15 @@ module PoolParty
   # Take the cloud dependency tree
   module DependencyResolverCloudExtensions    
     def to_properties_hash
-      oh = OrderedHash.new
+      oh = {}
       oh[:options] = options.merge(:cloud_name => name)
       oh[:resources] = ordered_resources.map {|a| a.to_properties_hash }
       # oh[:resources] = resources.keys.inject(OrderedHash.new) do |sum,k|
       #   sum.merge(k.to_sym => resources[k].map {|a| a.to_properties_hash } )
       # end
-      oh[:services] = services.keys.inject(OrderedHash.new) do |sum,k|
-        sum.merge(k.to_sym => services[k].map {|a| a.to_properties_hash } )
-      end
+      # oh[:services] = services.keys.inject(OrderedHash.new) do |sum,k|
+      #   sum.merge(k.to_sym => services[k].map {|a| a.to_properties_hash } )
+      # end
       oh
     end
     

data/lib/poolparty/dependency_resolver/puppet_resolver.rb

@@ -22,11 +22,7 @@ module PoolParty
     end
     
     def compile(props=@properties_hash, tabs=0)
-      [ 
-        # options_to_string(props[:options],tabs),
-        resources_to_string(props[:resources],tabs),
-        services_to_string(props[:services],tabs)
-      ].join("\n")
+      resources_to_string(props[:resources],tabs)
     end
     
     def options_to_string(opts,tabs=0)
@@ -62,6 +58,8 @@ module PoolParty
         case ty = resource.delete(:pp_type)
         when "variable"
           handle_print_variable(resource[:name], resource[:value], :variable)
+        when "plugin"
+          handle_print_service(resource.delete(:name), resource, tabs)
         else
           real_name = resource[:name]
           handle_print_resource(resource, ty.to_sym, tabs)
@@ -80,14 +78,6 @@ module PoolParty
       # end
     end
     
-    def services_to_string(opts,tabs=0)
-      if opts
-        opts.map do |klassname, klasshash|
-          handle_print_service(klassname, klasshash, tabs)
-        end
-      end
-    end
-    
     def hash_flush_out(hash, pre="", post="")
       setup_hash_for_output(hash).map do |k,v|
         hash.empty? ? nil : "#{pre}#{k} => #{v}#{post}"
@@ -135,28 +125,26 @@ module PoolParty
       end
     end
     
-    def handle_print_service(klassname, klassarray, tabs)
+    def handle_print_service(klassname, plugin, tabs)
       case klassname.to_s
       when "conditional"
         # "#{tf(tabs)}case $#{klasshash[:options][:variable]} {#{klasshash[:services][:control_statements].map do |k,v|"\n#{tf(tabs+1)}#{k} : {#{compile(v.to_properties_hash, tabs+2)}#{tf(tabs+1)}\n#{tf(tabs)}}" end}}"
-        
-        str = ""        
-        klassarray.each do |klasshash|
-          # str << "\n#{tf(tabs+1)}#{compile(hsh,tabs+1)}"
-          str << "#{tf(tabs)}case $#{klasshash[:options][:variable]} {"
-          str << "#{klasshash[:services][:control_statements].map do |k,v|"\n#{tf(tabs+1)}#{k} : {#{compile(v.to_properties_hash, tabs+2)}#{tf(tabs+1)}\n#{tf(tabs)}}" end}"
-        end        
-        str << "#{tf(tabs)}}"
+        # 
+        # str = ""        
+        # plugin.each do |klasshash|
+        #   # str << "\n#{tf(tabs+1)}#{compile(hsh,tabs+1)}"
+        #   str << "#{tf(tabs)}case $#{klasshash[:options][:variable]} {"
+        #   str << "#{klasshash[:services][:control_statements].map do |k,v|"\n#{tf(tabs+1)}#{k} : {#{compile(v.to_properties_hash, tabs+2)}#{tf(tabs+1)}\n#{tf(tabs)}}" end}"
+        # end        
+        # str << "#{tf(tabs)}}"
+        # deprecated conditional
         
       else
         kname = klassname.to_s.gsub(/pool_party_/, '').gsub(/_class/, '')
         str = "\n#{tf(tabs)}# #{kname}\n"
         str << "#{tf(tabs)}class #{kname} {"
-        klassarray.each do |hsh|
-          str << "\n#{tf(tabs+1)}#{compile(hsh,tabs+1)}"
-        end        
-        str << "#{tf(tabs)}} include #{kname}"
-        
+        str << "\n#{tf(tabs+1)}#{compile(plugin,tabs+1)}"
+        str << "#{tf(tabs)}} include #{kname}"        
       end
     end
     

data/lib/poolparty/lite.rb

@@ -8,8 +8,8 @@ end
 require "#{::File.dirname(__FILE__)}/poolparty/default"
 require "#{::File.dirname(__FILE__)}/modules/user_helpers"
 require "#{::File.dirname(__FILE__)}/schema"
-require "#{::File.dirname(__FILE__)}/net/init"
 require "#{::File.dirname(__FILE__)}/core/string"
+require "#{::File.dirname(__FILE__)}/net/init"
 require "#{::File.dirname(__FILE__)}/core/hash"
 require "#{::File.dirname(__FILE__)}/poolparty/neighborhoods"
 require "#{::File.dirname(__FILE__)}/exceptions/RemoteException.rb"

data/lib/poolparty/modules/searchable_paths.rb

@@ -0,0 +1,91 @@
+module PoolParty
+  # Abstracts out the searchable path for a resource such as a
+  # template file, key, or clouds.rb
+  #
+  # NOTE: this is currently _only_ implemented on templates
+  # (PoolParty::Resources::File) and not yet working on clouds.rb or key files.
+  # These will eventually be refactored to use this class.
+  module SearchablePaths
+    def self.included(mod)
+      mod.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Specify that a particular class has methods for searchable paths.
+      # 
+      # Options:
+      # * <tt>:dirs</tt>: array of directories to look in *under* the search paths. (default: <tt>["/"]</tt>)
+      # * <tt>:dir</tt>: set the directory to look in *under* the search paths. Use either dir or dirs, not both. (default: +/+)
+      # * <tt>:paths</tt>: overwrite all default paths and set the paths to this array exactly
+      # * <tt>:append_paths</tt>:  append these paths to any existing paths
+      # * <tt>:prepend_paths</tt>: prepend these paths to any existing paths
+      def has_searchable_paths(opts={})
+        class_eval do
+          extend PoolParty::SearchablePaths::SingletonMethods
+
+          @searchable_paths_dirs = [opts[:dir]] if opts[:dir]
+          @searchable_paths_dirs = opts[:dirs]  if opts[:dirs]
+          @paths_override        = opts[:paths] if opts[:paths]
+          @paths_prepend         = opts[:prepend_paths] || []
+          @paths_append          = opts[:append_paths]  || []
+        end
+        include PoolParty::SearchablePaths::InstanceMethods
+      end
+    end
+
+    module SingletonMethods
+      def searchable_paths_dir;  @searchable_paths_dirs.first; end
+      def searchable_paths_dirs
+        @searchable_paths_dirs && @searchable_paths_dirs.size > 0 ? @searchable_paths_dirs : ["/"]
+      end
+     
+      # The default paths are primarily defined in PoolParty::Default. These are the default search paths in order:
+      # 
+      # * current working directory (Dir.pwd)
+      # * ~/.poolparty
+      # * ~/.ec2
+      # * /etc/poolparty
+      # * /var/poolparty
+      def default_paths
+        [
+          Dir.pwd,
+          PoolParty::Default.poolparty_home_path,
+          PoolParty::Default.base_keypair_path,
+          PoolParty::Default.poolparty_src_path,
+          PoolParty::Default.poolparty_src_path/:lib/:poolparty,
+          PoolParty::Default.base_config_directory,
+          PoolParty::Default.remote_storage_path
+        ]
+      end
+
+      # returns the full set of valid searchable paths, given the options
+      def searchable_paths
+        return @paths_override if @paths_override && @paths_override.size > 0
+        @paths_prepend + default_paths + @paths_append
+      end
+    end
+
+    module InstanceMethods
+
+      # Searches for +filepath+ in the <tt>searchable_paths</tt> iff +filepath+
+      # doesn't exist. e.g. +filepath+ is interpreted *first* as an absolute
+      # path, if +filepath+ doesn't exist verbatim then it looks for the file
+      # in the searchable_paths.
+      # 
+      # Returns +nil+ if the file cannot be found.
+      def search_in_known_locations(filepath)
+        return filepath if File.exists?(filepath) # return the file if its an absolute path
+        self.class.searchable_paths.each do |path|
+          self.class.searchable_paths_dirs.each do |dir|
+            full_path = File.expand_path(path / dir / filepath)
+            return full_path if File.exists?(full_path)
+          end
+        end
+        nil
+      end
+      alias_method :find_file, :search_in_known_locations
+
+    end
+
+  end
+end

data/lib/poolparty/net/init.rb

@@ -7,5 +7,4 @@ end
 Dir["#{::File.dirname(__FILE__)}/remoter_bases/*/*.rb"].each do |base| 
   name = File.join(::File.basename(base, ::File.extname(base)))
   require base
-  register_remote_base name
 end

data/lib/poolparty/net/remote_bases.rb

@@ -17,5 +17,4 @@ end
 Dir["#{File.dirname(__FILE__)}/remote_bases/*.rb"].each do |base| 
   name = ::File.basename(base, ::File.extname(base))
   require base
-  register_remote_base name
 end

data/lib/poolparty/net/remoter_base.rb

@@ -33,6 +33,11 @@ module PoolParty
         instance_eval &block if block
         @cloud = prnt
       end
+      
+      def self.inherited(arg)
+        base_name = "#{arg}".downcase.top_level_class.to_sym
+        (remote_bases << base_name) unless remote_bases.include?(base_name)
+      end
 
       
       # def method_missing(meth, *args, &block)

data/lib/poolparty/net/remoter_bases/ec2/ec2.rb

@@ -105,7 +105,9 @@ module PoolParty
                               )
       end
       def self.ec2(o)
-        @ec2 ||= self.class.ec2(o)
+        @ec2 ||= EC2::Base.new( :access_key_id => o[:access_key], 
+                                :secret_access_key => o[:secret_access_key]
+                              )
       end
       
       # Get the ec2 description for the response in a hash format