auser-poolparty 1.0.0 → 1.1.1

data/lib/poolparty/dependency_resolver/chef_resolver.rb

@@ -0,0 +1,209 @@
+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
+    
+    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", :variables => hsh.dup})
+      end
+      # 
+      hsh.delete(:require) if hsh.has_key?(:require)
+      hsh
+    end
+    
+    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
+    
+    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
+    
+    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
+        "[ #{obj.map {|e| to_option_string(e) }.reject {|a| a.nil? || a.empty? }.join(", ")} ]"
+      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_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
@@ -26,7 +26,7 @@ module PoolParty
       # Most Resources won't need to extend this
       def to_string(pre="")
         return "" if printed?
-        opts = get_modified_options
+        opts = options #get_modified_options
         
         returning Array.new do |output|
           unless cancelled?
@@ -47,28 +47,29 @@ module PoolParty
           end
         end.join("\n")
       end
-      
-      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
+      #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,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/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

data/lib/poolparty/helpers/binary.rb

@@ -3,7 +3,7 @@ module PoolParty
   
   # Load a file that contains a pool into memory
   def load_pool(filename=nil)
-    filename = Binary.get_existing_spec_location#Dir["#{Dir.pwd}/**/*.rb"].select {|f| ::File.basename(f) == "clouds.rb" }.first unless filename
+    filename = filename || Binary.get_existing_spec_location
     dputs "Using spec at #{filename}"
     
     unless filename && ::File.readable?(filename)
@@ -11,7 +11,7 @@ module PoolParty
       exit(1)
     else
       $pool_specfile = filename
-      PoolParty::Script.inflate(open(filename).read, filename)
+      PoolParty::Pool::Pool.load_from_file filename
     end
   end
   
@@ -44,13 +44,13 @@ module PoolParty
       # These are the locations the spec file can be before the cloud
       # aborts because it cannot load the cloud
       def get_existing_spec_location
-        [
-            "#{Base.remote_storage_path}/#{Base.default_specfile_name}", 
-            "#{Base.default_specfile_name}",            
-            "#{Base.base_config_directory}/#{Base.default_specfile_name}",            
-            Dir["#{Dir.pwd}/*/clouds.rb"],
-            ENV["POOL_SPEC"],
-            "#{Base.storage_directory}/#{Base.default_specfile_name}"
+        [          
+          Dir["#{Dir.pwd}/*/clouds.rb"],
+          "#{Default.remote_storage_path}/#{Default.default_specfile_name}", 
+          "#{Default.default_specfile_name}",            
+          "#{Default.base_config_directory}/#{Default.default_specfile_name}",
+          "#{Default.poolparty_home_path}/#{Default.default_specfile_name}",          
+          ENV["POOL_SPEC"]
         ].flatten.reject {|a| a.nil?}.reject do |f|
           f unless ::File.readable?(f)
         end.first

data/lib/poolparty/helpers/display.rb

@@ -17,11 +17,7 @@ module PoolParty
       puts ""
       pools.size
     end
-    
-    def available_bases
-      remote_bases
-    end
-    
+        
     def header(str="")
       "*** #{str}"
     end

data/lib/poolparty/helpers/hash_printer.rb

@@ -0,0 +1,44 @@
+module PoolParty
+  class HashPrinter
+    def self.print_to_string(props={})
+<<-EOE
+Top Level
+  #{print_hash(props, 1)}
+EOE
+    end
+    def self.print_hash(props={}, tabs=0)
+      out = []
+      if props[:options]
+        out << props[:options].map {|k,v| "#{print_tabs(tabs)}#{k} => #{print_value(v)}"}.join("#{print_tabs(tabs)}\n")
+      end
+      if props[:resources]
+        props[:resources].each do |ty,r|
+          out << [
+            "#{print_tabs(tabs)}#{ty.to_s.capitalize}",
+            r.map {|h| h.map {|k,v| "#{print_tabs(tabs+1)}#{k} => #{print_value(v)}"}}.join("#{print_tabs(tabs+1)}\n")
+          ].join("\n")
+        end
+      end
+      if props[:services]
+        props[:services].each do |nm,s|
+          out << [
+            "#{print_tabs(tabs)}#{nm.to_s.capitalize}",
+            print_hash(s,tabs+1)
+          ].join("\n")
+        end
+      end
+      out.join("\n")
+    end
+    def self.print_tabs(tabs=1)
+      "#{"\t"*tabs}"
+    end
+    def self.print_value(v)
+      case v
+      when Array
+        "[#{v.join(", ")}]"
+      else
+        v
+      end
+    end
+  end
+end