fairchild-poolparty 1.1.5 → 1.2.12

data/lib/poolparty/dependency_resolver/chef_resolver.rb

@@ -20,13 +20,12 @@
 =end
 module PoolParty
   
-  class ChefResolver< DependencyResolver
+  class ChefResolver < DependencyResolver
     
     # Compile and add to the zipper
     def compile(props=@properties_hash, tabs=0, default_namespace="poolparty")
       base_dir(default_namespace)
       build_base_recipe_directory( default_namespace )
-      
       # ::Suitcase::Zipper.add( base_dir, "chef/cookbooks")
       
       _compile(props, tabs, default_namespace)
@@ -39,18 +38,13 @@ 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
     end
     
     def build_base_recipe_directory(nm)
-      dputs "Making new #{base_dir}"
       ::FileUtils.mkdir_p "#{base_dir}"
       
       [ "recipes", "templates", "attributes" ].each do |bdir|
@@ -65,7 +59,11 @@ module PoolParty
     end
     
     def base_dir(nm="poolparty")
-      @base_dir ||= "#{Default.tmp_path}/dr_configure/chef/cookbooks/#{nm}"
+      @base_dir ||= "#{tmp_path}/dr_configure/chef/cookbooks/#{nm}"
+    end
+    
+    def tmp_path
+      the_cloud ? the_cloud.tmp_path : "#{Default.tmp_path}/pool/cloud"
     end
     
     def options_to_string(opts,tabs=0)
@@ -73,7 +71,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 +80,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 +89,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 +137,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
@@ -165,26 +161,12 @@ module PoolParty
         hsh.merge!({:source => "#{nm}.erb"})
       end
       # 
-      hsh.delete(:require) if hsh.has_key?(:require)
+      hsh.delete(:require)
+      hsh.delete(:requires)
       hsh.delete(:name) # we don't need the names in the methods
       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 +179,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,14 +208,29 @@ 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
         "resources(:#{handle_chef_types(obj.class.to_s.top_level_class.downcase.to_sym)} => \"#{obj.name}\")"
       when Fixnum
-        "#{obj.to_i}"
+        case obj
+        when /^\d{3}$/
+          "0#{obj.to_i}"
+        else
+          "#{obj.to_i}"
+        end        
       when String
-        "\"#{obj}\""
+        case obj
+        when /^\d{4}$/
+          "#{obj}"
+        when /^\d{3}$/
+          "0#{obj}"
+        else
+          "\"#{obj}\""
+        end
+      when Proc
+        obj.call # eh
       when Array
         # If we are sending a notifies with a second argument
         if obj[1] && [:immediately, :delayed].include?(obj[1])

data/lib/poolparty/dependency_resolver/dependency_resolver.rb

@@ -10,7 +10,7 @@ module PoolParty
     
     attr_reader :properties_hash, :the_cloud
     
-    def initialize(hsh, contxt=nil)
+    def initialize(hsh, contxt={:tmp_path => "/tmp/poolparty/testpool/testcloud"})
       raise DependencyResolverException.new('must pass a hash') if hsh.nil? || !(hsh.instance_of?(OrderedHash) || hsh.instance_of?(Hash))
       @properties_hash = hsh
       @the_cloud = contxt

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[:options] = options.merge(:cloud_name => name)
+      oh = {}
+      oh[:options] = dsl_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
     
@@ -23,7 +23,7 @@ module PoolParty
   # Adds the to_properties_hash method on top of resources, the lowest level
   module DependencyResolverResourceExtensions
     def to_properties_hash
-      {:pp_type => self.class.to_s.top_level_class}.merge!(options)
+        {:pp_type => self.class.to_s.top_level_class}.merge!(dsl_options)
     end
   end
 end

data/lib/poolparty/dependency_resolver/puppet.rb

@@ -30,7 +30,6 @@ module PoolParty
         
         returning Array.new do |output|
           unless cancelled?
-            output << @prestring || ""
 
             if resources && !resources.empty? 
               output << resources_string_from_resources(resources, pre)

data/lib/poolparty/dependency_resolver/puppet_resolver.rb

@@ -5,12 +5,6 @@ module PoolParty
   
   class PuppetResolver< DependencyResolver
     
-    permitted_resource_options({
-      :global => [:require, :name],
-      :file => [:content, :mode, :user],
-      :exec => [:command, :path, :refreshonly]
-    })
-    
     def initialize(hsh=nil)
       super(hsh)
     end
@@ -22,11 +16,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 +52,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)
@@ -73,19 +65,6 @@ module PoolParty
     
     def permitted_option?(ty, key)
       true
-      # if permitted_resource_options.has_key?(ty)
-      #   permitted_resource_options[ty].include?(key) || true #permitted_resource_options[:global].include?(key)
-      # else
-      #   true
-      # 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="")
@@ -107,6 +86,10 @@ module PoolParty
           "present"
         end
       end
+
+      if hsh.has_key?(:requires)
+        hsh[:require] = hsh.delete(:requires)
+      end
       new_hsh ={}
       hsh.each do |k,v|
         new_hsh.merge!({k => to_option_string(v)})
@@ -135,29 +118,12 @@ module PoolParty
       end
     end
     
-    def handle_print_service(klassname, klassarray, 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)}}"
-        
-      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}"
-        
-      end
+    def handle_print_service(klassname, plugin, tabs)
+      kname = klassname.to_s.gsub(/pool_party_/, '').gsub(/_class/, '')
+      str = "\n#{tf(tabs)}# #{kname}\n"
+      str << "#{tf(tabs)}class #{kname} {"
+      str << "\n#{tf(tabs+1)}#{compile(plugin,tabs+1)}"
+      str << "#{tf(tabs)}} include #{kname}"        
     end
     
     def handle_print_variable(name, value, tabs)
@@ -197,4 +163,4 @@ module PoolParty
     
   end
 
-end
+end

data/lib/poolparty/exceptions/MasterException.rb

@@ -1,10 +1,10 @@
 class MasterException < Exception
-  EXCEPTION_MESSAGES = {
+  @messages = {
     :no_ip => "Master does not have an ip or has not been launched"
   }
   attr_reader :message
   
   def initialize(type=:no_ip, note="")
-    @message = "Master Exception: #{EXCEPTION_MESSAGES[type]} #{note}"
+    @message = "Master Exception: #{@messages[type]} #{note}"
   end
 end

data/lib/poolparty/extra/duration.rb

@@ -0,0 +1,96 @@
+module PoolParty
+  # Provides accurate date and time measurements using Date#advance and 
+  # Time#advance, respectively. It mainly supports the methods on Numeric,
+  # such as in this example:
+  #
+  #   1.month.ago       # equivalent to Time.now.advance(:months => -1)
+  class Duration
+    attr_accessor :value, :parts
+
+    def initialize(value, parts) #:nodoc:
+      @value, @parts = value, parts
+    end
+
+    # Adds another Duration or a Numeric to this Duration. Numeric values
+    # are treated as seconds.
+    def +(other)
+      if Duration === other
+        Duration.new(value + other.value, @parts + other.parts)
+      else
+        Duration.new(value + other, @parts + [[:seconds, other]])
+      end
+    end
+
+    # Subtracts another Duration or a Numeric from this Duration. Numeric
+    # values are treated as seconds.
+    def -(other)
+      self + (-other)
+    end
+
+    def -@ #:nodoc:
+      Duration.new(-value, parts.map { |type,number| [type, -number] })
+    end
+
+    def is_a?(klass) #:nodoc:
+      klass == Duration || super
+    end
+
+    # Returns true if <tt>other</tt> is also a Duration instance with the
+    # same <tt>value</tt>, or if <tt>other == value</tt>.
+    def ==(other)
+      if Duration === other
+        other.value == value
+      else
+        other == value
+      end
+    end
+
+    def self.===(other) #:nodoc:
+      other.is_a?(Duration) rescue super
+    end
+
+    # Calculates a new Time or Date that is as far in the future
+    # as this Duration represents.
+    def since(time = ::Time.current)
+      sum(1, time)
+    end
+    alias :from_now :since
+
+    # Calculates a new Time or Date that is as far in the past
+    # as this Duration represents.
+    def ago(time = ::Time.current)
+      sum(-1, time)
+    end
+    alias :until :ago
+
+    def inspect #:nodoc:
+      consolidated = parts.inject(::Hash.new(0)) { |h,part| h[part.first] += part.last; h }
+      [:years, :months, :days, :minutes, :seconds].map do |length|
+        n = consolidated[length]
+        "#{n} #{n == 1 ? length.to_s.singularize : length.to_s}" if n.nonzero?
+      end.compact.to_sentence
+    end
+
+    protected
+
+      def sum(sign, time = ::Time.current) #:nodoc:
+        parts.inject(time) do |t,(type,number)|
+          if t.acts_like?(:time) || t.acts_like?(:date)
+            if type == :seconds
+              t.since(sign * number)
+            else
+              t.advance(type => sign * number)
+            end
+          else
+            raise ::ArgumentError, "expected a time or date, got #{time.inspect}"
+          end
+        end
+      end
+
+    private
+
+      def method_missing(method, *args, &block) #:nodoc:
+        value.send(method, *args)
+      end
+  end
+end

data/lib/poolparty/helpers/binary.rb

@@ -1,4 +1,4 @@
-require "ftools"
+require "fileutils"
 module PoolParty
   
   # Load a file that contains a pool into memory

data/lib/poolparty/helpers/console.rb

@@ -1,10 +1,5 @@
-require File.dirname(__FILE__) + "/display"
-
 module PoolParty
   module Console
-    
-    include Display
-    
     # Print help commands for the console
     # level 0 - Basic help
     # level 1 - Commands

data/lib/poolparty/helpers/optioner.rb

@@ -9,10 +9,15 @@ module PoolParty
   class Optioner
     include Dslify
     
+    attr_accessor :loaded_pool, :loaded_clouds, :loaded_pools
+    
+    dsl_methods :spec,
+                :num,
+                :cloudname,
+                :poolname
+                
     default_options( :verbose => false, 
-                     :quiet => false, 
-                     :cloudname => false, 
-                     :poolname => false)
+                     :quiet => false)
     
     def initialize(args=[], opts={}, &block)
       boolean_args << opts[:boolean_args] if opts.has_key?(:boolean_args)
@@ -75,8 +80,8 @@ module PoolParty
     end
     
     def parse_options(&blk)
-      self.spec = nil
-      self.num = nil
+      self.spec nil
+      self.num nil
       
       progname = $0.include?("-") ? "#{::File.basename($0[/(\w+)-/, 1])} #{::File.basename($0[/-(.*)/, 1])}" : ::File.basename($0)
       @opts = OptionParser.new
@@ -89,7 +94,7 @@ module PoolParty
         @opts.separator "Options:"
         
         @opts.on('-v', '--verbose', 'Be verbose') { self.verbose true }  
-        @opts.on('-d', "--debug", "Debug setting") { self.debugging true }
+        @opts.on('-d', "--debug", "Debug setting") { self.debugging = true }
         @opts.on('-s [file]', '--spec-file [file]', 'Set the spec file') { |file| self.spec file.chomp }
         @opts.on('-t', '--test', 'Testing mode') { self.testing true }
         
@@ -106,20 +111,20 @@ module PoolParty
       @opts.parse(@arguments.dup)
       
       process_options
-      output_options if verbose
+      output_options if verbose? && verbose
       
       if @load_pools
-        self.loaded_pool load_pool( spec? ? spec : Binary.get_existing_spec_location)
-        self.loaded_clouds extract_cloud_from_options(self)
-        self.loaded_pools extract_pool_from_options(self)
+        @loaded_pool = load_pool( spec ? spec : Binary.get_existing_spec_location)
+        @loaded_clouds = extract_cloud_from_options(self)
+        @loaded_pools = extract_pool_from_options(self)
 
         reject_junk_options!
         raise CloudNotFoundException.new("Please specify your cloud with -s, move it to ./clouds.rb or in your POOL_SPEC environment variable") unless loaded_clouds && !loaded_clouds.empty?
         loaded_pools.each do |pl|
-          pl.options(self.options)
+          pl.dsl_options.merge!(self.dsl_options)
         end
         loaded_clouds.each do |cl|
-          cl.options(self.options)
+          cl.dsl_options.merge!(self.dsl_options)
         end
       end
     end
@@ -153,4 +158,4 @@ module PoolParty
   def extract_pool_from_options(o)
     o.poolname ? [pool(o.poolname.downcase.to_sym)] : pools.collect {|n,pl| pl}
   end
-end
+end

data/lib/poolparty/installers/base_installer.rb

@@ -0,0 +1,113 @@
+module PoolParty
+  module Installers
+    class BaseInstaller
+
+      include ::PoolParty::Remote
+      include ::PoolParty::Pinger
+      
+      def initialize
+        self.__send__ :welcome_message
+        commands.each {|c| self.__send__ c.to_sym }
+        self.__send__ :closing_message
+      end
+      
+      def welcome_message
+        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
+                
+        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
+        
+      end
+      
+      def closing_message
+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
+        say closing_message
+      end
+      
+      def commands
+        @commands ||= []
+      end
+      
+      protected
+      
+      def ask_with_help(opts={}, &block)
+        help_str = opts[:help]
+        message = opts[:message]
+
+        o = ask("#{message} (h for help)") do |q|    
+          q.validate = opts[:validate] if opts.has_key?(:validate)
+        end
+
+        if %w(h H).include?(o)
+          colored_say help_str, :help
+          ask_with_help(opts, &block)
+        else
+          block.call(o)
+        end
+        o
+      end
+
+      def rescued_ask(m, r)
+        begin
+          t = colored_ask m
+        rescue Exception => e
+          say r
+        end
+      end
+
+      def colored_ask(str, color = :notice)
+        setup_colors
+        ask("<%= color(\"#{str}\", :#{color}) %>")
+      end
+
+      def colored_say(str, color = :headline)
+        setup_colors
+        say("<%= color(\"#{str}\", :#{color}) %>") 
+      end
+
+      def setup_colors
+          unless @setup_colors
+          ft = HighLine::ColorScheme.new do |cs|
+            cs[:headline]         = [ :bold, :yellow, :on_black ]
+            cs[:horizontal_line]  = [ :bold, :white, :on_blue]
+            cs[:critical]         = [ :yellow, :on_red  ]
+            cs[:error]            = [ :bold, :red  ]
+            cs[:help]             = [ :bold, :white, :on_blue]
+            cs[:notice]           = [ :blue, :on_white]
+          end
+
+          HighLine.color_scheme = ft
+          @setup_colors = true
+        end
+      end
+      
+
+    end
+  end
+end
+
+Dir["#{::File.dirname(__FILE__)}/*.rb"].each {|lib| require lib }