fairchild-poolparty 1.1.4 → 1.1.5

data/lib/poolparty/base_packages/haproxy.rb

@@ -1,18 +1,14 @@
 module PoolParty
   class Base
-    plugin :poolparty_base_haproxy do
+    plugin :haproxy do
+      
+      def before_configure
+      end
       
       def enable
-        # We need the haproxy package
-        ::Suitcase::Zipper.add("#{::File.dirname(__FILE__)}/../../../vendor/chef/apache2", "chef/recipes")
+        # has_chef_recipe "apache2"
+        include_chef_recipe "#{::File.dirname(__FILE__)}/../../../vendor/chef/apache2"
 
-        has_chef_recipe 'apache2'
-        has_service "apache2"
-        
-        has_package({:name => "haproxy"}) do
-          stops get_service("apache2")
-        end
-    
         # Restart sysklogd after we update the haproxy.log
         has_service(:name => "sysklogd")    
         # Template variables
@@ -27,24 +23,36 @@ module PoolParty
         has_line_in_file(:line => "ENABLED=1", :file => "/etc/default/haproxy")
         has_line_in_file({:line => "SYSLOGD=\"-r\"", :file => "/etc/default/syslogd"})
         has_line_in_file({:line => "local0.* /var/log/haproxy.log", :file => "/etc/syslog.conf"}, {:notify => get_service("sysklogd")})
+        has_file '/var/log/haproxy.log' do
+          content ''
+        end
+        
+        has_directory "/var/run/haproxy"
+        has_package "apache2"
+        has_service "apache2"
+        
+        has_package "haproxy" do
+          stops get_service("apache2"), :immediately
+          # starts get_service("apache2")
+        end
 
         has_exec "reloadhaproxy", 
           :command => "/etc/init.d/haproxy reload", 
+          :ensures => "nothing",
           :requires => get_package("haproxy")
         
-        # Service is required
-        has_service("haproxy", :ensures => "running") do
-          stops get_service("apache2"), :immediately
-          starts get_service("apache2")
-        end
-        
-        has_directory "/var/run/haproxy"
-        
         has_file "/etc/haproxy/haproxy.cfg" do
           template "#{::File.dirname(__FILE__)}/../templates/haproxy.conf"
           calls get_exec("reloadhaproxy")
         end
         
+        # Service is required
+        has_service("haproxy") do
+          action [:start, :enable]
+          stops get_service("apache2"), :immediately
+          starts get_service("apache2")
+        end
+        
       end
     end
   end

data/lib/poolparty/base_packages/poolparty.rb

@@ -3,7 +3,7 @@ module PoolParty
     plugin :poolparty_base_packages do
       
       def enable
-        has_package "git"
+        has_package "git-core"
         
         has_cron "/usr/bin/server-manage-election" do
           minute "0,5,10,15,20,25,30,35,40,45,50,55"

data/lib/poolparty/capistrano.rb

@@ -39,7 +39,7 @@ module PoolParty
     end
     
     def set_role_for_all_instances(role, name)
-      ips = get_cloud(name).list_of_running_instances.map {|ri| ri.ip }
+      ips = get_cloud(name).nodes(:status => "running").map {|ri| ri.ip }
       ips.each {|ip| send :role, role.to_sym, "#{ip}"}
     end
   end

data/lib/poolparty/core/array.rb

@@ -6,31 +6,43 @@ class Array
   def to_os
     map {|a| a.to_os }
   end
+  
   def collect_with_index &block
     self.enum_for(:each_with_index).collect &block
   end
+  
   def runnable(quiet=true)
     self.join(" \n ").runnable(quiet)
   end
+  
   def nice_runnable(quiet=true)
     self.flatten.reject{|e| (e.nil? || e.empty?) }.join(" \n ").chomp.nice_runnable(quiet)
   end
+  
   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 respec_string(ns=[])
     "'#{map {|e| e.to_option_string }.join("', '")}'"
   end
   # Example  nodes.select_with_hash(:status=>'running')
   def select_with_hash(conditions={})
+    return self if conditions.empty?
     select do |node|
       conditions.any? do |k,v| 
         ( node.has_key?(k) && node[k]==v ) or ( node.respond_to?(k) && node.send(k)==v )
       end
     end
   end
+  
+  def wrapping_next(id)
+    raise "Element #{id} not in array" unless index(id)
+    index(id) >= size-1 ? at(0) : at(index(id)+1)
+  end
     
 end

data/lib/poolparty/core/hash.rb

@@ -3,7 +3,7 @@
 =end
 class Hash
   def choose(&block)
-    Hash[*self.select(&block).inject([]){|res,(k,v)| res << k << v}]    
+    Hash[*self.select(&block).inject([]){|res,(k,v)| res << k << v}]
   end
 
   def to_instance_variables(inst=nil)
@@ -30,6 +30,7 @@ class Hash
   #   o.keys.each {|k| self.delete(k) }
   #   o
   # end
+  
   def append(other_hash)
     returning Hash.new do |h|
       h.merge!(self)
@@ -38,23 +39,33 @@ class Hash
       end
     end
   end
+  
   def append!(other_hash)
     other_hash.each do |k,v|
       self[k] = has_key?(k) ? [self[k], v].flatten.uniq : 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 to_os
     m={}
     each {|k,v| m[k] = v.to_os }
     MyOpenStruct.new(m)
   end
+  
+  def next_sorted_key(from)
+    idx = (size - keys.sort.index(from))
+    keys.sort[idx - 1]
+  end
+  
   def method_missing(sym, *args, &block)
     if has_key?(sym)
       fetch(sym)
@@ -64,8 +75,4 @@ class Hash
       super
     end
   end
-  def next_sorted_key(from)
-    idx = (size - keys.sort.index(from))
-    keys.sort[idx - 1]
-  end
 end

data/lib/poolparty/core/nil.rb

@@ -0,0 +1,8 @@
+# Class: NilClas
+#
+#
+class NilClass
+  def empty?
+    true
+  end
+end

data/lib/poolparty/core/object.rb

@@ -72,19 +72,29 @@ class Object
   #   meta_undef name rescue ""
   # end
   def vputs(m="", o=self)
-    puts m if o.verbose rescue ""
+    # puts m if o.verbose rescue ""
+    puts "[INFO] -- #{m}" if verbose?
   end
   def vprint(m="", o=self)
     print m if o.verbose rescue ""
   end
   def dputs(m="", o=self)
-    puts "-- #{m}" if $DEBUGGING rescue ""
+    puts "[DEBUG] -- #{m.inspect}" if debugging?(o) rescue ""
   end
-  def debugging(bool=false)
-    $DEBUGGING = bool
+  def dprint(m="", o=self)
+    print "#{m}" if debugging?(o) || verbose?(o) rescue ""
+  end
+  def verbose?(o=self)
+    o.respond_to?(:verbose) ? o.verbose : ($TESTING ||= false)
+  end
+  def debugging?(o=self)
+    o.respond_to?(:debug) ? o.debug : ($DEBUGGING ||= false)
+  end
+  def debugging(bool=nil)
+    bool.nil? ? $DEBUGGING : $DEBUGGING = bool
   end
   def testing(bool=$TESTING)
-    bool.nil? ? false : bool
+    bool.nil? ? $TESTING : $TESTING = bool
   end
   alias :debug :debugging
   def unix_hide_string

data/lib/poolparty/core/string.rb

@@ -119,10 +119,10 @@ class String
   # Examples
   #   "Module".constantize #=> Module
   #   "Class".constantize #=> Class
-  def constantize
+  def constantize(mod=Object)
     camelcased_word = camelcase
     begin
-      Object.module_eval(camelcased_word, __FILE__, __LINE__)
+      mod.module_eval(camelcased_word, __FILE__, __LINE__)
     rescue NameError
       puts "#{camelcased_word} is not defined."
       nil
@@ -151,4 +151,30 @@ class String
       arr << self.split(/\n/).collect_with_index(&block)
     end.flatten
   end
+  
+  # Read a new-line separated string and turn 
+  # the string from the form 
+  #   a = "b"
+  #   b = "c"
+  # into a hash
+  #  {:a => "b", :b => "c"}
+  def to_hash
+    split("\n").inject({}) do |sum,line| 
+      if line.include?("=")
+        l = line.split("=").map {|a| a.strip }
+        key = l[0].to_sym
+        value = l[1].gsub(/\"/, '')
+        sum.merge(key => value)
+      else
+        sum
+      end
+    end
+  end
+  
+  # Take a mac address and split it to map to the arp -a response
+  # Just rip off the first 0 if the first char is 0
+  def macify
+    split(":").map {|a| a[0].chr == "0" ? a[1].chr : a}.join(":")
+  end
+  
 end

data/lib/poolparty/dependency_resolver/chef_resolver.rb

@@ -1,35 +1,71 @@
+=begin rdoc
+  ChefResolver
+  
+  This takes the internal structure
+  {
+    :options => {},
+    :services => [{}],
+    :resources => []
+  }
+  
+  and creates a chef recipe to reflect.
+  
+  /cookbooks/
+    namespace/
+      recipes/
+      templates/
+      attributes/
+  
+  TODO: This class is somewhat all over the place. Slim it down
+=end
 module PoolParty
   
   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)
+    end
+    
+    def _compile(props=@properties_hash, tabs=0, default_namespace="poolparty")
       cld_name = default_namespace
       comp(cld_name, props, tabs)
     end
     
     def comp(cld_name, props, tabs)
-      base_dir cld_name
-      basedir = build_base_recipe_directory( cld_name )
-      # handle_print_variables(props[:options]) if props && props.has_key?(:options)
       
       default_recipe = [ 
         resources_to_string(props[:resources],tabs),
         services_to_string(props[:services],tabs)
       ].join("\n")
-      ::File.open("#{basedir}/recipes/default.rb", "w+") {|f| f << default_recipe }        
-      ::Suitcase::Zipper.add(basedir, "chef/recipes/cookbooks")
+
+      ::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|
-        ::FileUtils.mkdir_p "#{base_dir}/#{bdir}" unless ::File.directory? "#{base_dir}/#{bdir}"
+        ::FileUtils.mkdir_p "#{base_dir}/#{bdir}" #unless ::File.directory? "#{base_dir}/#{bdir}"
+      end
+      
+      ::File.open("#{base_dir}/attributes/poolparty.rb", "w") do |f| 
+        f << "poolparty Mash.new unless attribute?('poolparty')\n"
       end
+      
       base_dir
     end
     
-    def base_dir(nm=nil)
-      @base_dir ||= "#{Default.tmp_path}/dr_configure/chef/recipes/#{nm}"
+    def base_dir(nm="poolparty")
+      @base_dir ||= "#{Default.tmp_path}/dr_configure/chef/cookbooks/#{nm}"
     end
     
     def options_to_string(opts,tabs=0)
@@ -37,63 +73,42 @@ module PoolParty
     end
     
     def resources_to_string(opts,tabs=0)
-      out = []
-      if opts
-
-        if opts[:variable] && !opts[:variable].empty?
-          vars = opts.delete(:variable)          
-          handle_print_variables(vars)
-        end
-        
-        if opts[:chef_recipe]
-          opts.delete(:chef_recipe).each do |rcp|
-            out << "include_recipe #{to_option_string(rcp.name)}"
-          end          
-        end
-        
-        if opts.has_key?(:line_in_file)
-          lines = opts.delete(:line_in_file).inject([]) do |sum, l|
-            sum << PoolParty::Resources::Exec.new(:name => l[:name], :command => PoolParty::Resources::LineInFile.command(l[:line], l[:file]) ).to_properties_hash
-          end          
-          if lines && lines.size > 0            
-            opts.has_key?(:exec) ? (opts[:exec] << lines) : opts.merge!(:exec => lines)
-          end
-        end
-        
-        out << opts.map do |type, arr|
-          arr.map do |res|
-            real_type = handle_types(type)
-            real_name = handle_names(type, res)
-            res = before_filter_check_on_hash(res, real_name)
-            "#{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
+      out = []        
+      out << opts.map do |resource|
+        case ty = resource.delete(:pp_type)
+        when "variable"
+          handle_print_variable(resource)
+        when "chef_recipe"
+          "#{tf(tabs)}include_recipe #{to_option_string(resource.name)}"
+        when "chef_library"
+          "#{tf(tabs)}require #{to_option_string("/etc/chef/lib/#{resource.name}")}"
+        else
+          real_type = handle_chef_types(ty)
+          real_name = resource[:name]
+          res = before_filter_check_on_hash(resource, real_name)          
+          "#{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
+      end      
       out.join("\n")
     end
     
-    def handle_print_variables(vars)
-      
-      out = ["\npoolparty Mash.new unless attribute?('poolparty')\n\n"]
-      vars.each do |varhash|
-        out << "#{varhash[:namespace] || "poolparty"}[:#{varhash[:name]}] = #{to_option_string(varhash[:value])}"
-      end
-      ::File.open("#{base_dir}/attributes/poolparty.rb", "w+") do |f| 
-        f << out.join("\n")
-      end
-    end
-    
-    def handle_chef_vars(nm, varname)
-      case varname
-      when :enable
-        "action"
+    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"
       else
-        "#{nm}[:#{varname}]"
+        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
+      ""
     end
-    
-    def handle_types(ty)
-      case ty
+        
+    def handle_chef_types(ty)
+      case ty.to_sym
       when :exec
         "execute"
       when :file
@@ -102,27 +117,23 @@ module PoolParty
         "link"
       when :line_in_file
         "execute"
+      when :chef_deploy_definition
+        "deploy"
       else
         ty
       end
     end
-    
-    def handle_names(ty, res)
-      case ty
-      when :exec
-        res.name
-      else
-        res.name
-      end
-    end
-    
-    # TODO: This is brittle, need to find a way to make them reactive, rather than 
-    # separate (the key/value pairs)
-    def hash_flush_out(hash, pre="", post="")      
+
+    # flush out the hash into something meaningful
+    def hash_flush_out(hash, pre="", post="") 
       hash.map do |k,v|
-        key = to_chef_key(k)
-        res = to_option_string(v)
-        (key.nil? || res.nil?) ? nil : "#{pre}#{key} #{res}#{post}"
+        if o = handle_actions(k,v)
+          o
+        else
+          key = to_chef_key(k)
+          res = to_option_string(v)
+          (key.nil? || res.nil?) ? nil : "#{pre}#{key} #{res}#{post}"
+        end
       end
     end
     
@@ -133,9 +144,9 @@ module PoolParty
       else
         kname = klassname.to_s.gsub(/pool_party_/, '').gsub(/_class/, '')
         str = "\n#{tf(tabs)}# #{kname}\n"
-        str << "#{tf(tabs+1)}"
+        str << "#{tf(tabs)}"
         klassarray.each do |hsh|
-          str << compile(hsh,tabs+1, klassname)
+          str << _compile(hsh,tabs+1, klassname)
         end        
         str << "#{tf(tabs)}"
       end
@@ -147,12 +158,15 @@ module PoolParty
       if hsh.has_key?(:content)
         cont = hsh.delete(:content)
         temp_file = "#{base_dir}/templates/default/#{nm}.erb"
+        
         ::FileUtils.mkdir_p(::File.dirname(temp_file)) unless ::File.directory? temp_file
         ::File.open(temp_file, "w+") {|f| f.print cont }
+        
         hsh.merge!({:source => "#{nm}.erb"})
       end
       # 
       hsh.delete(:require) if hsh.has_key?(:require)
+      hsh.delete(:name) # we don't need the names in the methods
       hsh
     end
     
@@ -171,6 +185,16 @@ module PoolParty
       end
     end
     
+    # Handle ensures
+    def handle_actions(key,value)
+      case key
+      when :ensures
+        value.nil? ? nil : "action :#{value}"
+      else
+        nil
+      end
+    end
+    
     # Take the keys from the resource hash and turn them into chef-like
     # meaningful keys. This is how helpers are created for chef
     def to_chef_key(key)
@@ -189,9 +213,9 @@ module PoolParty
         nil
       when :if_not
         "not_if"
-      when :notif
+      when :not_if
         "not_if"
-      when :onlyif
+      when :only_if
         "only_if"
       else
         "#{key}"        
@@ -203,12 +227,13 @@ module PoolParty
     def to_option_string(obj)
       case obj
       when PoolParty::Resources::Resource
-        "resources(:#{handle_types(obj.class.to_s.top_level_class.downcase.to_sym)} => \"#{obj.name}\")"
+        "resources(:#{handle_chef_types(obj.class.to_s.top_level_class.downcase.to_sym)} => \"#{obj.name}\")"
       when Fixnum
         "#{obj.to_i}"
       when String
         "\"#{obj}\""
       when Array
+        # If we are sending a notifies with a second argument
         if obj[1] && [:immediately, :delayed].include?(obj[1])
           "#{to_option_string(obj[0])}, :#{obj[1]}"
         else
@@ -216,6 +241,8 @@ module PoolParty
         end        
       when nil
         nil
+      when Symbol
+        ":#{obj}"
       when Hash
         "#{obj.map {|k,v| ":#{k} => #{to_option_string(v)}" unless v == obj }.compact.join(",\n")}"
       else

data/lib/poolparty/dependency_resolver/dependency_resolver.rb

@@ -11,7 +11,7 @@ module PoolParty
     attr_reader :properties_hash, :the_cloud
     
     def initialize(hsh, contxt=nil)
-      raise DependencyResolverException.new('must pass a hash') if hsh.nil? || (!hsh.instance_of?(OrderedHash) && !hsh.instance_of?(Hash))
+      raise DependencyResolverException.new('must pass a hash') if hsh.nil? || !(hsh.instance_of?(OrderedHash) || hsh.instance_of?(Hash))
       @properties_hash = hsh
       @the_cloud = contxt
     end

data/lib/poolparty/dependency_resolver/dependency_resolver_cloud_extensions.rb

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