poolparty 0.2.84 → 1.2.2

data/lib/poolparty/dependency_resolver/chef_resolver.rb

@@ -0,0 +1,237 @@
+=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)
+      
+      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|
+        ::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="poolparty")
+      @base_dir ||= "#{Default.tmp_path}/dr_configure/chef/cookbooks/#{nm}"
+    end
+    
+    def options_to_string(opts,tabs=0)
+      handle_print_variables(opts) if opts
+    end
+    
+    def resources_to_string(opts,tabs=0)
+      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}")}"
+        when "plugin"
+          handle_print_service(resource, tabs)
+        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      
+      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"
+      else
+        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)
+      case ty.to_sym
+      when :exec
+        "execute"
+      when :file
+        "template"
+      when :symlink
+        "link"
+      when :line_in_file
+        "execute"
+      when :chef_deploy_definition
+        "deploy"
+      else
+        ty
+      end
+    end
+
+    # flush out the hash into something meaningful
+    def hash_flush_out(hash, pre="", post="") 
+      hash.map do |k,v|
+        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
+    
+    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)}"
+        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
+    # to provide a check
+    def before_filter_check_on_hash(hsh, nm)
+      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
+    
+    # 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
+    # 
+    # * <tt>reloads</tt> - todo
+    def to_chef_key(key)
+      case key
+      when :ensures
+        nil
+      when :reloads
+        "notifies :reload,"
+      when :calls
+        "notifies :run,"
+      when :stops
+        "notifies :stop,"
+      when :starts
+        "notifies :start,"
+      when :enable
+        nil
+      when :if_not
+        "not_if"
+      when :not_if
+        "not_if"
+      when :only_if
+        "only_if"
+      else
+        "#{key}"        
+      end
+    end
+    
+    # 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}"
+      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
+          "[ #{obj.map {|e| to_option_string(e) }.reject {|a| a.nil? || a.empty? }.join(", ")} ]"
+        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
+        "#{obj}"
+      end
+    end
+    
+  end
+
+end

data/lib/poolparty/dependency_resolver/dependency_resolver.rb

@@ -0,0 +1,42 @@
+=begin rdoc
+  DependencyResolver
+  
+  This acts as the interface between PoolParty's dependency tree
+  and the dependency providers. To add a new DependencyResolver,
+  overload this class with the appropriate calls
+=end
+module PoolParty
+  class DependencyResolver
+    
+    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))
+      @properties_hash = hsh
+      @the_cloud = contxt
+    end
+    
+    # Compile the clouds properties_hash into the format required by the dependency resolver
+    # This methods should be overwritten by the supclassed methods
+    def compile()
+      raise "Not Implemented"
+    end
+    
+    def self.compile(hsh, contxt=nil)
+      new(hsh, contxt).compile
+    end
+    
+    def self.permitted_resource_options(rules={})
+      @permitted_resource_options ||= rules
+    end
+    
+    def permitted_resource_options
+      self.class.permitted_resource_options
+    end
+    
+    def tf(count)
+      "\t" * count
+    end
+    
+  end
+end

data/lib/poolparty/dependency_resolver/dependency_resolver_cloud_extensions.rb

@@ -0,0 +1,29 @@
+=begin rdoc
+  Cloud extensions for the DependencyResolver
+=end
+
+module PoolParty
+  # Take the cloud dependency tree
+  module DependencyResolverCloudExtensions    
+    def to_properties_hash
+      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
+    end
+    
+  end
+  
+  # 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)
+    end
+  end
+end

data/lib/poolparty/{dependency_resolutions → dependency_resolver}/puppet.rb

@@ -1,11 +1,11 @@
 module PoolParty
-  module Resources
-    class Resource
-      def self.resource_string_name(n, key)
-        "#{n.to_s.sanitize.capitalize}['#{key}']"
-      end
-    end
-  end
+  # module Resources
+  #   class Resource
+  #     def self.resource_string_name(n, key)
+  #       "#{n.to_s.sanitize.capitalize}['#{key}']"
+  #     end
+  #   end
+  # end
   
   module DependencyResolutions
     module Puppet
@@ -25,12 +25,14 @@ module PoolParty
       # Generic to_s
       # Most Resources won't need to extend this
       def to_string(pre="")
-        opts = get_modified_options
+        return "" if printed?
+        opts = options #get_modified_options
+        
         returning Array.new do |output|
           unless cancelled?
             output << @prestring || ""
 
-            if resources && !resources.empty?
+            if resources && !resources.empty? 
               output << resources_string_from_resources(resources, pre)
             end
             
@@ -39,32 +41,35 @@ module PoolParty
               output << opts.flush_out("#{pre*2}").join(",\n")
               output << "#{pre}}"
             end
-          
+            
+            printed
             output << @poststring || ""
           end
         end.join("\n")
       end
-      
-      def resources_string_from_resources(res, pre="\t")
-        @variables = res.extract! {|name,resource| name == :variable}
-        
-        returning Array.new do |str|
-          unless @variables.empty?
-            str << "\n# Variables"
-            @variables.each do |name, variable|
-              str << variable.to_string("#{pre}")
-            end          
-          end
 
-          res.reject do |type, resource|
-            str << resource.to_string("#{pre*2}")
-          end
-        end.join("\n")
-      end
+      #TODO: deprecated
+      # def resources_string_from_resources(res, pre="\t")
+      #   return nil if res.keys == [:classpackage] && res.size == 1
+      #   @variables = res.extract! {|name,resource| name == :variable}
+      #   
+      #   returning Array.new do |str|
+      #     unless @variables.empty?
+      #       str << "\n# Variables"
+      #       @variables.each do |name, variable|
+      #         str << variable.to_string("#{pre}")
+      #       end          
+      #     end
+      # 
+      #     res.reject do |type, resource|
+      #       str << resource.to_string("#{pre*2}")
+      #     end
+      #   end.join("\n")
+      # end
       
-      def to_s
-        self.class.resource_string_name(class_type_name.capitalize, key)
-      end
+      # def to_s
+      #   self.class.resource_string_name(class_type_name.capitalize, key)
+      # end
     end
   end
 end

data/lib/poolparty/dependency_resolver/puppet_resolver.rb

@@ -0,0 +1,188 @@
+# Class: PuppetResolver< DependencyResolver
+#
+#
+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
+    
+    def self.compile(props)
+      "class poolparty {
+        #{new(props).compile}
+      }"
+    end
+    
+    def compile(props=@properties_hash, tabs=0)
+      resources_to_string(props[:resources],tabs)
+    end
+    
+    def options_to_string(opts,tabs=0)
+      opts.map do |k,v| 
+        res = to_option_string(v)
+        next unless res && !res.empty?
+        "#{tf(tabs)}$#{k} = #{res}"
+      end.join("\n") if opts
+    end
+    
+    def resources_to_string(opts,tabs=0)
+      out = []
+      if opts
+        if opts.has_key?(:variable)
+          vars = opts.delete(:variable)
+          out << vars.map do |res, arr|
+            handle_print_resource(res, :variable, tabs)
+          end
+        end
+
+        out << opts.map do |type, arr|
+          arr.map do |res|
+            handle_print_resource(res, type, tabs)
+          end
+        end
+      end
+      out.join("\n")
+    end
+    
+    def resources_to_string(opts,tabs=0)
+      out = []        
+      out << opts.map do |resource|
+        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)
+        end
+      end      
+      out.join("\n")
+    end
+    
+    
+    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 hash_flush_out(hash, pre="", post="")
+      setup_hash_for_output(hash).map do |k,v|
+        hash.empty? ? nil : "#{pre}#{k} => #{v}#{post}"
+      end
+    end
+    
+    def setup_hash_for_output(hsh)
+      ty = hsh.delete(:klasstype)
+      if hsh.has_key?(:ensures)
+        hsh.delete(:ensures)
+        hsh[:ensure] = case ty.to_s
+        when "directory"
+          "directory"
+        when "symlink"
+          hsh[:source]
+        else
+          "present"
+        end
+      end
+      new_hsh ={}
+      hsh.each do |k,v|
+        new_hsh.merge!({k => to_option_string(v)})
+      end
+      new_hsh
+    end
+        
+    def to_option_string(obj)
+      case obj
+      when PoolParty::Resources::Resource
+        case obj
+        when PoolParty::Resources::Directory
+          "File[\"#{obj.name}\"]"
+        else
+          "#{obj.class.to_s.top_level_class.capitalize}[\"#{obj.name}\"]"
+        end        
+      when Fixnum
+        "#{obj}"
+      when String
+        obj = obj
+        obj =~ /generate\(/ ? "#{obj}" : "\"#{obj.safe_quote}\""
+      when Array
+        "[ #{obj.map {|e| to_option_string(e) }.reject {|a| a.nil? || a.empty? }.join(", ")} ]"
+      else
+        "#{obj}"
+      end
+    end
+    
+    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 = ""        
+        # 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} {"
+        str << "\n#{tf(tabs+1)}#{compile(plugin,tabs+1)}"
+        str << "#{tf(tabs)}} include #{kname}"        
+      end
+    end
+    
+    def handle_print_variable(name, value, tabs)
+      "$#{name} = #{to_option_string(value)}"
+    end
+    
+    def handle_print_resource(res, type, tabs)
+      case type.to_s        
+      when "line_in_file"
+        "#{tf(tabs)}exec { \"#{res[:file]}_line_#{tabs}\": \n#{tf(tabs+1)}command => '#{PoolParty::Resources::LineInFile.command(res[:line], res[:file])}',\n#{tf(tabs+1)}path => '/usr/local/bin:$PATH'\n#{tf(tabs)}}"
+      else
+        klasstype = case type.to_s
+        when "directory"
+          "file"
+        when "symlink"
+          "file"
+        else
+          type
+        end
+        res.merge!(:klasstype => type.to_s)
+        "#{tf(tabs)}#{klasstype} { \"#{res.delete(:name) }\": #{res.empty? ? "" : "\n#{tf(tabs+1)}#{hash_flush_out(res.reject {|k,v| !permitted_option?(type, k) }).reject {|s| s.nil? }.join(",\n#{tf(tabs+1)}")}"}\n#{tf(tabs)}}"
+      end
+    end
+    
+    # This is the method we use to turn the options into a string to build the main 
+    # puppet manifests
+    def option_type(ns=[])
+      a_template = (self =~ /template/) == 0
+      a_service = self =~ /^[A-Z][a-zA-Z]*\[[a-zA-Z0-9\-\.\"\'_\$\{\}\/]*\]/i
+      a_function = self =~/(.)*\((.)*\)(.)*/
+      if is_a?(PoolParty::Resources::Resource)
+        self.to_s
+      else
+        (a_service || a_template || a_function) ? self : "'#{self}'"
+      end    
+    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/exceptions/RemoteException.rb

@@ -3,7 +3,7 @@ class RemoteException < Exception
     :method_not_defined => "Method is not defined",
     :invalid_formatting => "Invalid formatting",
     :could_not_install => "Could not install"
-  }
+  } unless const_defined?("EXCEPTION_MESSAGES")
   attr_reader :message
   
   def initialize(type=:method_not_defined, note="")

data/lib/poolparty/exceptions/dependency_resolver_exception.rb

@@ -0,0 +1,5 @@
+class DependencyResolverException < Exception  
+  def initialize(msg="Compile Error")
+    @message = "Dependency resolver error: #{msg}"
+  end
+end

data/lib/poolparty/exceptions/package_exception.rb

@@ -0,0 +1,7 @@
+class PackageException < Exception
+  attr_reader :message
+  
+  def initialize(msg="Package error")
+    @message = "Package error: #{msg}"
+  end
+end

data/lib/poolparty/extra/deployments.rb

@@ -1,31 +1,31 @@
+#TODO: Reimplement
 module PoolParty
   module Extra
-    class Deployments
+    class Deployments        
 
-      class << self
-        
-        def include_deployment(filename)
+        def self.include_deployment(filename)
           return nil unless ::File.file? filename
           name = ::File.basename(filename, ::File.extname(filename))
           contents = open(filename).read
 
           plugin_klass = PoolParty::PluginModel::PluginModel.new(name)
-          plugin_klass.klass.class_eval <<-EOE
+          plugin_klass.class_eval <<-EOE
             def enable
+              puts "Called enable"
               #{contents}
             end
           EOE
           plugin_klass
         end
         
-        def include_deployments(dir)
+        def self.include_deployments(dir)
           return nil unless ::File.directory? dir
           Dir["#{dir}/*"].each do |fi|
             include_deployment fi
           end
           dir
         end
-      end
+        
     end    
   end
 end