fairchild-poolparty 1.1.3

data/lib/poolparty/dependency_resolver/chef_resolver.rb

@@ -0,0 +1,221 @@
+module PoolParty
+  
+  class ChefResolver< DependencyResolver
+    
+    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")
+      default_recipe
+    end
+    
+    def build_base_recipe_directory(nm)
+      [ "recipes", "templates", "attributes" ].each do |bdir|
+        ::FileUtils.mkdir_p "#{base_dir}/#{bdir}" unless ::File.directory? "#{base_dir}/#{bdir}"
+      end
+      base_dir
+    end
+    
+    def base_dir(nm=nil)
+      @base_dir ||= "#{Default.tmp_path}/dr_configure/chef/recipes/#{nm}"
+    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}"
+      handle_print_variables(opts) if opts
+      # end.join("\n") if opts
+    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.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
+        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"
+      else
+        "#{nm}[:#{varname}]"
+      end
+    end
+    
+    def handle_types(ty)
+      case ty
+      when :exec
+        "execute"
+      when :file
+        "template"
+      when :symlink
+        "link"
+      when :line_in_file
+        "execute"
+      else
+        ty
+      end
+    end
+    
+    def handle_names(ty, res)
+      case ty
+      when :exec
+        res.name
+      else
+        res.name
+      end
+    end
+    
+    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}"
+      end
+    end
+    
+    def handle_print_service(klassname, klassarray, tabs)
+      case klassname
+      when nil
+        nil
+      else
+        kname = klassname.to_s.gsub(/pool_party_/, '').gsub(/_class/, '')
+        str = "\n#{tf(tabs)}# #{kname}\n"
+        str << "#{tf(tabs+1)}"
+        klassarray.each do |hsh|
+          str << compile(hsh,tabs+1, klassname)
+        end        
+        str << "#{tf(tabs)}"
+      end
+    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
+    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
+    
+    # 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)
+      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 :onlyif
+        "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_types(obj.class.to_s.top_level_class.downcase.to_sym)} => \"#{obj.name}\")"
+      when Fixnum
+        "#{obj.to_i}"
+      when String
+        "\"#{obj}\""
+      when Array
+        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 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,28 @@
+=begin rdoc
+  Cloud extensions for the DependencyResolver
+=end
+
+module PoolParty
+  # Take the cloud dependency tree
+  module DependencyResolverCloudExtensions    
+    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[: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
+      options
+    end
+  end
+end

data/lib/poolparty/dependency_resolver/puppet.rb

@@ -0,0 +1,75 @@
+module PoolParty
+  # module Resources
+  #   class Resource
+  #     def self.resource_string_name(n, key)
+  #       "#{n.to_s.sanitize.capitalize}['#{key}']"
+  #     end
+  #   end
+  # end
+  
+  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="")
+        return "" if printed?
+        opts = options #get_modified_options
+        
+        returning Array.new do |output|
+          unless cancelled?
+            output << @prestring || ""
+
+            if resources && !resources.empty? 
+              output << resources_string_from_resources(resources, pre)
+            end
+            
+            unless virtual_resource?
+              output << "#{pre}#{class_type_name.downcase} { #{pre}\"#{self.key}\":"
+              output << opts.flush_out("#{pre*2}").join(",\n")
+              output << "#{pre}}"
+            end
+            
+            printed
+            output << @poststring || ""
+          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
+    end
+  end
+end

data/lib/poolparty/dependency_resolver/puppet_resolver.rb

@@ -0,0 +1,173 @@
+# 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)
+      [ 
+        # options_to_string(props[:options],tabs),
+        resources_to_string(props[:resources],tabs),
+        services_to_string(props[:services],tabs)
+      ].join("\n")
+    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, arr, tabs)
+          end
+        end
+
+        out << opts.map do |type, arr|
+          arr.map do |res|
+            handle_print_resource(res, type, arr, tabs)
+          end
+        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 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="")
+      hash.map do |k,v|
+        key = to_puppet_key(k)
+        res = to_option_string(v)
+        res.empty? ? nil : "#{pre}#{key} => #{res}#{post}"
+      end
+    end
+    
+    def to_puppet_key(key)
+      case key
+      when :ensures
+        "ensure"
+      else
+        "#{key}"        
+      end
+    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, 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
+    end
+    
+    def handle_print_resource(res, type, arr, tabs)
+      case type.to_s
+      when "variable"
+        "$#{res[:name]} = #{to_option_string(res[:value])}"
+      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
+        "#{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/CloudNotFoundException.rb

@@ -0,0 +1,7 @@
+class CloudNotFoundException < Exception
+  attr_reader :message
+  
+  def initialize(msg="Cloud not found")
+    @message = "Cloud not found: #{msg}"
+  end
+end

data/lib/poolparty/exceptions/LoadRulesException.rb

@@ -0,0 +1,7 @@
+class LoadRulesException < Exception
+  attr_reader :message
+  
+  def initialize(msg="It looks like your rules are malformed")
+    @message = "Load Malformed rule: #{msg}"
+  end
+end

data/lib/poolparty/exceptions/MasterException.rb

@@ -0,0 +1,10 @@
+class MasterException < Exception
+  EXCEPTION_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}"
+  end
+end

data/lib/poolparty/exceptions/ProvisionerException.rb

@@ -0,0 +1,5 @@
+class ProvisionerException < Exception  
+  def initialize(msg="Provisioner process failed")
+    @message = "Error: #{msg}"
+  end
+end

data/lib/poolparty/exceptions/RemoteException.rb

@@ -0,0 +1,12 @@
+class RemoteException < Exception
+  EXCEPTION_MESSAGES = {
+    :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="")
+    @message = "Remote Exception: #{EXCEPTION_MESSAGES[type]} #{note}"
+  end
+end

data/lib/poolparty/exceptions/ResourceException.rb

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

data/lib/poolparty/exceptions/RuntimeException.rb

@@ -0,0 +1,7 @@
+class RuntimeException < Exception
+  attr_reader :message
+  
+  def initialize(msg="Runtime exception")
+    @message = "There was a runtime error: #{msg}"
+  end
+end

data/lib/poolparty/exceptions/SpecException.rb

@@ -0,0 +1,7 @@
+class SpecException < Exception
+  attr_reader :message
+  
+  def initialize(msg="Custom resource exception")
+    @message = "Spec error: #{msg}"
+  end
+end

data/lib/poolparty/exceptions/TemplateNotFound.rb

@@ -0,0 +1,7 @@
+class TemplateNotFound < Exception
+  attr_reader :message
+  
+  def initialize(msg="Custom resource exception")
+    @message = "Template not found: #{msg}"
+  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/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

@@ -0,0 +1,31 @@
+#TODO: Reimplement
+module PoolParty
+  module Extra
+    class Deployments        
+
+        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.class_eval <<-EOE
+            def enable
+              puts "Called enable"
+              #{contents}
+            end
+          EOE
+          plugin_klass
+        end
+        
+        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