fairchild-poolparty 1.1.5 → 1.2.12

data/lib/poolparty/poolparty/plugin.rb

@@ -3,32 +3,34 @@ require "#{::File.dirname(__FILE__)}/../provision/boot_strapper.rb"
 
 module PoolParty
   module Plugin
+    
+    def self.available
+      @available_plugins ||= []
+    end
         
     class Plugin < PoolParty::Service
       include CloudResourcer
       include PoolParty::DependencyResolverCloudExtensions
       include PoolParty::Callbacks
-            
-      default_options({})
       
-      def initialize(opts={}, prnt=nil, &block)
-        before_load(opts, &block)
+      dsl_methods :name
+      
+      def initialize(opts={}, extra_opts={}, prnt=nil, &block)
+        setup_callbacks
+        
+        run_in_context {  before_load(opts, &block) }
         
         block = Proc.new {enable} unless block
-
-        @opts = opts        
+        
         super(opts, &block)
         
-        run_in_context do
-          loaded @opts, &block
-        end
+        run_in_context { loaded opts, &block }
         
-        setup_callbacks
         after_create
       end
       
       # Overwrite this method
-      def before_load(o={}, &block)        
+      def before_load(o={}, &block)
       end
       def loaded(o={}, &block)
       end
@@ -36,11 +38,21 @@ module PoolParty
       def after_create
       end
       
+      def calls(r)
+        has_exec "ls", :calls => r
+      end
+      
       def enable
       end
       def is_plugin?
         true
       end
+      def cloud
+        context_stack.find do |i|
+          i.class == PoolParty::Cloud::Cloud
+        end
+      end
+      
       def bootstrap_gems *gems
         gems.each do |g|
           Provision::BootStrapper.gem_list << g unless Provision::BootStrapper.gem_list.include?(g)
@@ -56,8 +68,32 @@ module PoolParty
       end
       
       def self.inherited(subclass)
-        method_name = subclass.to_s.top_level_class.gsub(/pool_party_/, '').gsub(/_class/, '').downcase.to_sym
-        add_has_and_does_not_have_methods_for(method_name)
+        
+        klass = subclass.to_s.split('::').pop.to_s
+        add_has_and_does_not_have_methods_for(klass.snake_case)
+        add_resource_lookup_method(klass.snake_case)
+        
+        # Add the plugin definition to the cloud as an instance method
+        # For example apache do; apache option and method; end
+        meth = <<-EOM
+          def #{klass.snake_case}(opts={}, &block)
+            i = plugin_store.select {|i| i if i.class.to_s =~ /#{klass}/ }.first if plugin_store
+            if i
+              i
+            else
+              inst = ::PoolParty::Plugin::#{klass}.new(opts, parent, &block)               
+              plugin_store << inst if plugin_store
+              inst
+            end
+          end
+        EOM
+        
+        ::PoolParty::PoolPartyBaseClass.module_eval meth
+        
+        # Store the plugins so they will be availble in an array at Plugin.available
+        ::PoolParty::Plugin.available << subclass
+        super
+        
       end
       
     end

data/lib/poolparty/poolparty/pool.rb

@@ -11,7 +11,7 @@ module PoolParty
     
     def with_pool(pl, opts={}, &block)
       raise CloudNotFoundException.new("Pool not found") unless pl
-      pl.options.merge!(opts) if pl.options
+      pl.dsl_options.merge!(opts) if pl.dsl_options
       pl.run_in_context &block if block
     end
     
@@ -29,11 +29,9 @@ module PoolParty
 
     class Pool < PoolParty::PoolPartyBaseClass
       include PrettyPrinter
-      include CloudResourcer # WHY?!?! TODO: check on this
+      include CloudResourcer
       include Remote
       
-      default_options Default.default_options
-      
       def initialize(name,&block)
         @pool_name = name
         @pool_name.freeze
@@ -45,21 +43,46 @@ module PoolParty
 
         super(&block)
       end
+      
+      
       def self.load_from_file(filename=nil)
         # a = new ::File.basename(filename, ::File.extname(filename))
-        File.open(filename, 'r') do |f|
-          instance_eval f.read, pool_specfile
+        #TODO: load any user defined monitors plugins verifiers before the cloud spec is evaled
+        #%w(monitors plugins verifiers).each do |lib|
+        #  Dir[File.join(::File.dirname(::File.basename(filename)), lib, '*')].each{|f| require f }
+        # end
+        call_before_all_loaded(pool_specfile || filename)
+        o = File.open(filename, 'r') do |f|
+          instance_eval f.read, (pool_specfile || filename)
+        end
+        o.call_after_all_loaded if o.respond_to?(:call_after_all_loaded)
+        o
+      end
+      
+      # callbacks
+      def self.call_before_all_loaded(filepath)
+        # Load the plugins
+        $:.unshift(::File.dirname(filepath))
+        Dir["#{::File.dirname(filepath)}/plugins/*"].each do |plugin_path|
+          $:.unshift(plugin_path)
         end
-        # a
       end
+      
+      def after_all_loaded(&block)
+        @after_all_loaded ||= block
+      end
+      
+      def call_after_all_loaded
+        after_all_loaded.call if after_all_loaded
+      end
+      
       def name(*args)
         @pool_name ||= @pool_name ? @pool_name : (args.empty? ? :default_pool : args.first)
       end
 
       def parent;nil;end
       
-      def setup_defaults        
-        PoolParty::Extra::Deployments.include_deployments "#{Dir.pwd}/deployments"
+      def setup_defaults
       end
       
       def pool_clouds

data/lib/poolparty/poolparty/poolparty_base_class.rb

@@ -1,5 +1,12 @@
+$:.unshift(::File.dirname(__FILE__))
+$:.unshift("#{::File.dirname(__FILE__)}/../../../vendor/gems/*")
+$:.unshift("#{::File.dirname(__FILE__)}/../../../vendor/gems/dslify/lib")
+$:.unshift("#{::File.dirname(__FILE__)}/../../../vendor/gems/parenting/lib")
+
+require "default"
 require "dslify"
 require "parenting"
+
 module PoolParty
   
   def context_stack
@@ -7,10 +14,17 @@ module PoolParty
   end
   
   class PoolPartyBaseClass
-    include Dslify, Parenting
+    attr_reader :init_opts
+    
+    include Parenting, Dslify
     
     include PoolParty::DependencyResolverCloudExtensions
+    include PoolParty::SearchablePaths
+    
     # attr_accessor :depth
+    has_searchable_paths
+    
+    default_options Default.dsl_options
 
     def initialize(opts={}, extra_opts={}, &block)
       add_to_parent_if_parent_exists_and_is_a_service
@@ -18,23 +32,31 @@ module PoolParty
       @init_block = block
       @base_name = get_name_from_options_and_extra_options(opts, extra_opts)
       
-      o = (opts.is_a?(Hash) ? extra_opts.merge(opts) : extra_opts).merge(:name => @base_name)
-      
-      run_in_context(o, &block)
-      super(&block)
+      @init_opts = (opts.is_a?(Hash) ? extra_opts.merge(opts) : extra_opts.merge(:name => @base_name))
+
+      run_in_context(init_opts, &block)
+      # super(init_opts, &block)
     end
     
     # Overloading the parent run_in_context
-    def run_in_context(o={}, &block)
-      if o
-        context_stack.push self
-        set_vars_from_options(o)
-        instance_eval &block if block
-        context_stack.pop
-      else
-        super
+    def run_in_context(o={}, &block)      
+      context_stack.push self        
+      set_vars_from_options(o)
+      instance_eval &block if block
+      context_stack.pop
+    end
+    
+    def run_with_callbacks(o, &block)
+      run_in_context(o) do
+        before_load(o, &block)
+        yield if block_given?
+        loaded(o, &block)
       end
     end
+
+    def search_in_known_locations(filepath, additional_search_paths=[])
+      find_file(filepath, [::File.dirname(pool_specfile)])
+    end    
     
     # Add the parent's options to my own and add myself as a service if I am not a resource
     def add_to_parent_if_parent_exists_and_is_a_service      
@@ -46,22 +68,26 @@ module PoolParty
     
     # Try to extract the name from the options
     def get_name_from_options_and_extra_options(opts={}, extra_opts={})
-      opts.is_a?(Hash) ? (opts.has_key?(:name) ? opts.delete(:name) : nil) : dsl_options[:name] = opts
+      opts.is_a?(Hash) ? (opts.has_key?(:name) ? opts[:name] : nil) : dsl_options[:name] = opts
     end
     
     # Add to the services pool for the manifest listing
-    def add_service(serv, extra_name="")
-      subclass = "#{serv.class.to_s.top_level_class.underscore.downcase}#{extra_name}"
-      lowercase_class_name = subclass.to_s.underscore.downcase || subclass.downcase
-      
-      (services[lowercase_class_name.to_sym] ||= []) << serv if serv && !serv.empty?
-      # services.merge!({lowercase_class_name.to_sym => serv})
+    def add_service(serv)      
+      ordered_resources << serv
     end
-    # Container for the services
-    def services
-      @services ||= OrderedHash.new
+    
+    def inspect
+      to_properties_hash.inspect
     end
     
+    def to_hash
+      to_properties_hash
+    end
+          
+    def to_json
+      to_hash.to_json
+    end
+
     def resources
       @resources ||= OrderedHash.new
     end
@@ -78,7 +104,7 @@ module PoolParty
     # A word about stores, the global store stores the entire list of stored
     # resources. The local resource store is available on all clouds and plugins
     # which stores the instance variable's local resources. 
-    def add_resource(ty, opts={}, extra_opts={}, &block)    
+    def add_resource(ty, opts={}, extra_opts={}, &block)       
       temp_name = get_name_from_options_and_extra_options(opts, extra_opts)
       
       if res = get_resource(ty, temp_name, opts)        
@@ -87,7 +113,8 @@ module PoolParty
         opts = (opts.is_a?(Hash) ? extra_opts.merge(opts) : extra_opts).merge(:name => temp_name)
         
         # opts.merge!(:name => temp_name) unless opts.has_key?(:name)
-        res = if PoolParty::Resources::Resource.available_resources.include?(ty.to_s.camelize)
+        res = if (PoolParty::Resources::Resource.available_resources.include?(ty.to_s.camelize) || 
+                  PoolParty::Resources::Resource.available_resources.include?("PoolParty::Resources::#{ty.to_s.camelize}".camelize.constantize))
           "PoolParty::Resources::#{ty.to_s.camelize}".camelize.constantize.new(opts, &block)
         else
           "#{ty.to_s.camelize}".camelize.constantize.new(opts.merge(:name), &block)
@@ -129,7 +156,8 @@ module PoolParty
     
     def ordered_resources
       @ordered_resources ||= []
-    end
+    end    
+    attr_writer :ordered_resources
     
     def is_plugin?
       false
@@ -139,24 +167,6 @@ module PoolParty
       false
     end
     
-    def method_missing(m,*a,&block)
-      if this_context && this_context != self && this_context.respond_to?(m)# && !self.is_a?(PoolParty::Resources::Resource)
-        this_context.send m, *a, &block      
-      else
-        # if dsl_options.has_key?(m)
-        #          dsl_options[m]
-        #        elsif parent && parent.respond_to?(:dsl_options) && parent.dsl_options.has_key?(m)
-        #          parent.dsl_options[m]
-        #        elsif self.class.default_options.has_key?(m)
-        #          self.class.default_options[m]
-        #        elsif parent && parent.respond_to?(:dsl_options) && parent.default_options.has_key?(m)
-        #          parent.default_options[m]
-        #        else
-          super
-        # end
-      end
-    end
-    
     # Adds two methods to the module
     # Adds the method type:
     #   has_
@@ -169,7 +179,7 @@ module PoolParty
     # TODO: Refactor nicely to include other types that don't accept ensure
     def self.add_has_and_does_not_have_methods_for(typ=:file)
       method_name = "__#{typ}"
-      PoolParty::PoolPartyBaseClass.module_eval <<-EOE
+      ev=<<-EOE
         def has_#{typ}(opts={}, extra={}, &block)
           #{method_name}({:ensures => :present}.merge(handle_option_values(opts).merge(extra)), &block)
         end
@@ -177,6 +187,16 @@ module PoolParty
           #{method_name}({:ensures => :absent}.merge(handle_option_values(opts).merge(extra)), &block)
         end
       EOE
+      PoolParty::PoolPartyBaseClass.module_eval ev, ($pool_specfile || "")
+    end
+    
+    def self.add_resource_lookup_method(lookup_type=:file)
+      ev=<<-EOE
+        def #{lookup_type}s
+          ordered_resources.select {|q| q if q.class.to_s =~ /#{lookup_type.to_s.classify}/ }
+        end
+      EOE
+      PoolParty::PoolPartyBaseClass.module_eval ev, ($pool_specfile || "")
     end
     
     def handle_option_values(o)

data/lib/poolparty/poolparty/resource.rb

@@ -14,10 +14,7 @@ module PoolParty
     end
     
     class Resource < PoolParty::PoolPartyBaseClass
-      attr_accessor :prestring, :poststring
-      
-      # include CloudResourcer
-      
+            
       # For the time being, we'll make puppet the only available dependency resolution
       # base, but in the future, we can rip this out and make it an option
       # include PoolParty::DependencyResolutions::Puppet
@@ -26,6 +23,9 @@ module PoolParty
       # DSL Overriders
       include PoolParty::ResourcingDsl
       
+      # ability to have searchable paths on resources
+      include SearchablePaths
+
       # When we subclass Resource, we want to add a few methods to the Resources class
       # This will anable us to call out to these resources in our DSLified manner
       # When we call a method from the subclass, say it's the File class
@@ -37,6 +37,7 @@ module PoolParty
       # those methods. Then we make sure we add these resources as available_resources
       # onto the class so we know it's available as a resource
       def self.inherited(subclass)
+        original_subclass = subclass
         subclass = subclass.to_s.split("::")[-1] if subclass.to_s.index("::")
         lowercase_class_name = subclass.to_s.underscore.downcase || subclass.downcase
         method_name = "__#{lowercase_class_name}".to_sym
@@ -57,8 +58,9 @@ module PoolParty
           EOE
           PoolParty::PoolPartyBaseClass.module_eval method
           PoolParty::PoolPartyBaseClass.add_has_and_does_not_have_methods_for(lowercase_class_name.to_sym)
+          PoolParty::PoolPartyBaseClass.add_resource_lookup_method(lowercase_class_name)
           
-          available_resources << subclass
+          available_resources << original_subclass
         end
       end
       
@@ -68,6 +70,13 @@ module PoolParty
         @available_resources ||= []
       end
       
+      dsl_methods :action, 
+                  :not_if, 
+                  :if_not, 
+                  :only_if, 
+                  :calls,
+                  :requires
+      
       # This is set in order of descending precedence
       # The options are overwritten from the bottom up
       # and the resource will use those as the values
@@ -76,11 +85,12 @@ module PoolParty
       # Finally, it uses the parent's options as the lowest priority
       def initialize(opts={}, extra_opts={}, &block)
         super(opts, extra_opts, &block)
-                
+        
         @resource_name = @base_name
-        dsl_options[:name] = resource_name unless dsl_options.has_key?(:name)
+        # dsl_options[:name] = @init_opts[:name] unless dsl_options.has_key?(:name) && dsl_options[:name]
         
-        loaded(opts, &block)
+        # p [:name, name, dsl_options, init_opts] # methods.sort.join(", ")
+        loaded(init_opts, &block)
         
         after_create
       end
@@ -94,14 +104,14 @@ module PoolParty
       def resource_name
         @resource_name ||= nil
       end
-      
-      def name(*args)
-        resource_name
-      end
-      
+            
       # After create callback
       def after_create
       end
+      def before_load(o={}, &block)
+      end
+      def after_load(o={}, &block)
+      end
       
       # We don't want to inherit the services on a resource, as resources
       # are a base and should never have services.
@@ -125,33 +135,6 @@ module PoolParty
       def class_type_name
         self.class.to_s.top_level_class.underscore.downcase
       end
-      def self.custom_function(str)
-        custom_functions << str
-      end
-      def self.custom_functions
-        @custom_functions ||= []
-      end
-      def custom_function(str)
-        self.class.custom_functions << str
-      end
-            
-      def self.custom_functions_to_string(pre="")
-        returning Array.new do |output|
-          PoolParty::Resources.available_custom_resources.each do |resource|
-            resource.custom_functions.each do |func|
-              output << "#{pre*2}#{func}"
-            end
-          end
-        end.join("\n")
-      end
-      # Some things in puppet aren't allowed, so let's override them here
-      def disallowed_options
-        []
-      end
-
-      def key
-        name
-      end
       # def virtual_resource?
       #   false
       # end
@@ -166,14 +149,6 @@ module PoolParty
         true
       end
       
-      def method_missing(m,*a,&block)
-        if parent && parent.dsl_options.has_key?(m) && is_in_plugin?
-          parent.send m, *a, &block
-        else
-          super
-        end
-      end
-      
       # Private method just for resource retrievling purposes
       def class_name_sym
         self.class.to_s.top_level_class.downcase.to_sym
@@ -206,4 +181,4 @@ module PoolParty
   end
 end
 
-Dir["#{::File.dirname(__FILE__)}/../resources/*.rb"].each {|lib| require "#{lib}"}
+Dir["#{::File.dirname(__FILE__)}/../resources/*.rb"].each {|lib| require "#{lib}"}

data/lib/poolparty/poolparty/service.rb

@@ -2,8 +2,12 @@ module PoolParty
   
   class Service < PoolPartyBaseClass
     
-    def initialize(o={}, &block)
-      super(o, &block)
+    include PoolParty::DependencyResolverCloudExtensions
+    
+    def to_properties_hash
+      { :pp_type => "plugin", :options => dsl_options, 
+        :name => (dsl_options[:name] ? dsl_options[:name] : self.class.to_s.split('::').pop.snake_case),
+        :resources => ordered_resources.map {|a| a.to_properties_hash }}
     end
     
     def cloud
@@ -13,20 +17,18 @@ module PoolParty
       nil
     end
     
-    def self.add_has_and_does_not_have_methods_for(typ=:file)
-      lowercase_class_name = typ.to_s.top_level_class.downcase
-      
+    def self.add_has_and_does_not_have_methods_for(typ=:file)      
       meth = <<-EOM
-        def __#{lowercase_class_name}(opts={}, &block)
-          i = PoolParty::#{lowercase_class_name.camelcase}Class.new(opts, &block)
+        def __#{typ}(opts={}, &block)
+          i = ::PoolParty::Plugin::#{typ.camelcase}.new(opts, &block)
           plugin_store << i if respond_to?(:plugin_store)
           i
         end
-        alias :#{lowercase_class_name} :__#{lowercase_class_name}
+        alias :#{typ} :__#{typ}
       EOM
       
       PoolParty::PoolPartyBaseClass.module_eval meth
-      PoolParty::PoolPartyBaseClass.add_has_and_does_not_have_methods_for(lowercase_class_name.to_sym)
+      PoolParty::PoolPartyBaseClass.add_has_and_does_not_have_methods_for(typ.to_sym)
     end
     
   end