poolparty 0.2.84 → 1.2.2

data/lib/poolparty/poolparty/resource.rb

@@ -6,193 +6,125 @@
   
   Most of the Resources will not need to create their own
 =end
-module PoolParty    
+module PoolParty
   module Resources
-    
-    def resources
-      @resources ||= {}
-    end
-    
-    def resource(type=:file)
-      resources[type] ||= []
-    end
-    
-    def add_resource(type, opts={}, parent=self, &block)
-      if opts[:name] && in_a_resource_store?(type, opts[:name])
-        @res = get_from_local_resource_store(type, opts[:name], parent)
-        @res ||= get_from_global_resource_store(type, opts[:name])
-        # if should_duplicate_resource?(type, @res, parent, opts)
-        # unless @res.parent == parent
-        #   @pa = parent
-        #   @res.instance_eval {@parent = @pa}
-        # end
-          # parent.resource(type) << @res
-        # end
-      else
-        @res = returning "PoolParty::Resources::#{type.to_s.camelize}".camelize.constantize.new(opts, parent, &block) do |o|                    
-          store_into_global_resource_store(o)
-          resource(type) << o          
-        end        
-      end
-      @res
-    end
-    def should_duplicate_resource?(type, res, pare, opts)
-      pare != @res.parent && 
-        pare.cloud != @res.cloud && 
-        in_global_resource_store?(type, opts[:name]) && 
-        !in_resources?(type, res, pare)
-    end
-    def get_resource(ty, key, parent=self)
-      get_from_local_resource_store(ty, key, parent) || get_from_global_resource_store(ty, key)
-    end
-    def get_from_local_resource_store(type, key, parent)
-      resource(type).select {|r| r.key == key }.first
-    end
-    def in_a_resource_store?(type, key, parent=self)
-      !(get_resource(type, key) && in_global_resource_store?(type, key)).nil?
-    end
-    def in_resources?(type, key, parent=self)
-      !get_resource(type, key).nil?
-    end
-    def global_resources_store
-      $global_resources ||= []
-    end
-    def store_into_global_resource_store(r)
-      global_resources_store << r unless in_global_resource_store?(r.class_name_sym, r.key)
-    end
-    def get_from_global_resource_store(ty, key)
-      global_resources_store.select {|r| r if r.same_resources_of(ty, key) }.first
-    end
-    def in_global_resource_store?(ty, key)
-      !get_from_global_resource_store(ty, key).nil?
-    end
-    #:nodoc:
-    def reset_resources!
-      $global_resources = $global_classpackage_store = @resources = nil
-    end
-        
-    # def resources_string(pre="")
-    #   returning Array.new do |output|        
-    #     output << resources_string_from_resources(resources)
-    #   end.join("\n")
-    # end
+
     
     def custom_file(path, str)
       write_to_file_in_storage_directory(path, str)
     end
-        
-    class Resource
+    
+    class Resource < PoolParty::PoolPartyBaseClass
       attr_accessor :prestring, :poststring
       
-      include CloudResourcer
-      include Configurable
+      # 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
+      # include PoolParty::DependencyResolutions::Puppet
+      include PoolParty::DependencyResolverResourceExtensions
       
-      extend PoolParty::Resources
-      include PoolParty::Resources
+      # 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
+      # then we want to be able to have the method file() available.
+      # We also want to be able to fetch the resource with a get_file method.
+      # This will just call out to get the resource. If the resource isn't available
+      # in a resource store, we expect to return a nil result. 
+      # Finally, the has_ and does_not_have_ methods are appended. See below for 
+      # 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)
         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
         
         # Add add resource method to the Resources module
-        unless PoolParty::Resources.respond_to?(lowercase_class_name.to_sym)          
+        unless PoolParty::PoolPartyBaseClass.respond_to?(method_name)
           method =<<-EOE
-            def #{lowercase_class_name}(opts={}, parent=self, &blk)
-              add_resource(:#{lowercase_class_name}, opts, parent, &blk)
+            private 
+            def #{method_name}(opts={}, &blk)              
+              add_resource(:#{lowercase_class_name}, opts, &blk)
             end
-            def get_#{lowercase_class_name}(n, opts={}, parent=self, &block)
-              res = in_a_resource_store?(:#{lowercase_class_name}, n) ?
-                get_resource(:#{lowercase_class_name}, n) :
-                nil
-                # PoolParty::Resources::Resource.resource_string_name(#{lowercase_class_name}, n)
-                # add_resource(:#{lowercase_class_name}, opts, parent, &blk)
-              # res ||= PoolParty::Resources::Resource.resource_string_name(#{lowercase_class_name}, n)
+            def get_#{lowercase_class_name}(n, opts={}, &block)
+              res = get_resource(:#{lowercase_class_name}, n, opts, &block)
+              raise PackageException.new("Oops. Check that you specified the #{lowercase_class_name} \#\{n\}.") unless res
               res
             end
+            public
           EOE
-          PoolParty::Resources.module_eval method
-          PoolParty::Resources.add_has_and_does_not_have_methods_for(lowercase_class_name.to_sym)
+          PoolParty::PoolPartyBaseClass.module_eval method
+          PoolParty::PoolPartyBaseClass.add_has_and_does_not_have_methods_for(lowercase_class_name.to_sym)
           
           available_resources << subclass
         end
       end
       
+      # Keep track of the resources that are available. This way we can show some pretty output
+      # later and ensure that we are only calling available resources
       def self.available_resources
         @available_resources ||= []
       end
       
-      def self.available_resource_methods
-        available_resources.map {|a| a.my_methods }
-      end
-      
       # 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
       # Then it takes the value of the block and sets whatever is sent there as 
       # the options
       # Finally, it uses the parent's options as the lowest priority
-      def initialize(opts={}, parent=self, &block)                        
-        run_setup(parent, &block)
-        # Take the options of the parents
-        set_vars_from_options(opts) unless opts.empty?
+      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)
         
-        set_resource_parent
+        loaded(opts, &block)
         
-        loaded(opts, @parent)
-      end
-      
-      # Helper to set the containing parent on the resource
-      def set_resource_parent
-        if @parent && @parent != self
-          if can_set_requires_for_parent
-            # requires @parent.to_s
-          end
-        end
-      end
-      
-      def can_set_requires_for_parent
-        @parent.is_a?(PoolParty::Resources::Resource) && 
-          @parent.printable? && 
-          @parent.name != name &&
-          !@parent.is_a?(PoolParty::Resources::Classpackage)
+        after_create
       end
             
       # Stub, so you can create virtual resources
       # This is called after the resource is initialized
       # with the options given to it in the init-block
-      def loaded(opts={}, parent=self)
+      def loaded(opts={}, &block)
       end
       
-      def cloud
-        @pa = parent
-        while !(@pa.is_a?(PoolParty::Cloud::Cloud) || @pa.nil? || @pa == self)
-          @pa = @pa.respond_to?(:parent) ? @pa.parent : nil
-        end
-        @pa
+      def resource_name
+        @resource_name ||= nil
       end
       
-      def parent_tree
-        @pa = self
-        returning Array.new do |arr|
-          while !(@pa.is_a?(PoolParty::Cloud::Cloud) || @pa.nil? || @pa == self)
-            @pa = @pa.respond_to?(:parent) ? @pa.parent : nil
-            arr << @pa
-          end
-        end
+      def name(*args)
+        resource_name
       end
       
-      # DSL Overriders
-      include PoolParty::ResourcingDsl
+      # After create callback
+      def after_create
+      end
       
-      def same_resources_of(t, k)
-        key == k && class_name_sym == t
+      # We don't want to inherit the services on a resource, as resources
+      # are a base and should never have services.
+      def services
       end
+      
+      def cloud
+        2.upto(context_stack.size) do |i|
+          return ::PoolParty.context_stack[-i] if ::PoolParty.context_stack[-i].is_a?(PoolParty::Cloud::Cloud)
+        end
+        nil
+      end
+      
       def duplicatable?
         false
       end
+      def resource?
+        true
+      end
       # This way we can subclass resources without worry
       def class_type_name
         self.class.to_s.top_level_class.underscore.downcase
@@ -220,23 +152,32 @@ module PoolParty
       def disallowed_options
         []
       end
-      def allowed_options
-        [
-          :subscribe, :owner, :group, :path, :mode, :source, :notify, :subscribe, :check, :creates, :cwd, :command, :ensure,
-          :require, :schedule, :range, :alias, :hour, :minute, :user, :month, :monthday, :name, :onlyif, :unless, :refreshonly,
-          :refresh, :content, :template, :ip, :repeat, :provider, :key, :device, :fstype, :remounts, :options, :atboot, :before,
-          :binary, :status, :start, :stop, :restart, :pattern, :recurse, :home
-        ]
-      end
+
       def key
         name
       end
-      def virtual_resource?
-        false
+      # def virtual_resource?
+      #   false
+      # end
+      # def printable?
+      #   true
+      # end
+      def is_in_plugin?
+        parent.is_plugin?
       end
-      def printable?
+      
+      def is_a_resource?
         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
@@ -248,8 +189,8 @@ module PoolParty
       # it returns an empty hash
       def get_modified_options
         unless @modified_options
-          if options
-            opts = options.inject({}) do |sum,h|
+          if dsl_options
+            opts = dsl_options.inject({}) do |sum,h|
               sum.merge!({h[0].to_sym => ((h[1].nil?) ? self.send(h[0].to_sym) : h[1]) })
             end
           else
@@ -258,42 +199,15 @@ module PoolParty
           @full_allowed_options ||= allowed_options.reject {|ele| disallowed_options.include?(ele) }
           @modified_options = opts.reject do |k,v|
             !@full_allowed_options.include?(k) || 
-              @parent && @parent.respond_to?(:options) && @parent != self && @parent.options.has_key?(k) && @parent.options[k] == options[k]
+              @parent && @parent.respond_to?(:dsl_options) && @parent != self && @parent.dsl_options.has_key?(k) && @parent.dsl_options[k] == dsl_options[k]
           end
         end
         @modified_options
       end
-    end
-    
-    # Adds two methods to the module
-    # Adds the method type:
-    #   has_
-    # and 
-    #   does_not_have_
-    # for the type passed
-    # for instance
-    # add_has_and_does_not_have_methods_for(:file)
-    # gives you the methods has_file and does_not_have_file
-    # TODO: Refactor nicely to include other types that don't accept ensure
-    def self.add_has_and_does_not_have_methods_for(type=:file)
-      module_eval <<-EOE
-        def has_#{type}(opts={}, parent=self, &block)
-          #{type}(handle_option_values(opts).merge(:ensures => "present"), parent, &block)
-        end
-        def does_not_have_#{type}(opts={}, parent=self, &block)
-          #{type}(handle_option_values(opts).merge(:ensures => "absent"), parent, &block)
-        end
-      EOE
-    end
-    
-    def handle_option_values(o)
-      case o.class.to_s
-      when "String"
-        {:name => o}
-      else
-        o
-      end
+      
     end
     
   end
-end
+end
+
+Dir["#{::File.dirname(__FILE__)}/../resources/*.rb"].each {|lib| require "#{lib}"}

data/lib/poolparty/poolparty/script.rb

@@ -1,43 +1,55 @@
+require "parenting"
 module PoolParty
   
   class Script
+    include Parenting
     
     def self.inflate_file(file)
       inflate open(file).read if file
     end
         
     def self.inflate(script, file="__SCRIPT__")
-      apool = new
-      apool.instance_eval script, file
-      apool.inflate
+      module_eval script, file
+      # a = new
+      # a.instance_eval <<-EOM
+      #   def run_child(pa)
+      #     context_stack.push pa
+      #     #{str}
+      #     context_stack.pop
+      #     remove_method(:run_child)
+      #     self
+      #   end
+      # EOM
+      # a.run_child(self)
+      # a
     end
-    
-    def inflate
-      pools.map {|name,pool| pool.inflate } unless pools.empty?
-    end
-    
+        
     def self.to_ruby(opts={},&blk)
       blk.to_ruby(opts)
     end
     
     def self.for_save_string
-      returning Array.new do |out|
-        pools.collect {|n,pl| pl}.each do |pl|
-          out << "pool :#{pl.name} do"
-          clouds.each do |n,cl|
-            out << <<-EOE
-  cloud :#{cl.name} do
-    #{cl.minimum_runnable_options.map {|o| "#{o} #{cl.send(o).respec_string}"}.join("\n")}
-  end
-            EOE
+      out = []
+      pools.collect {|n,pl| pl}.each do |pl|
+        out << "pool :#{pl.name} do"
+        clouds.each do |n,cl|
+          # grossy-gross
+          minimum_runnable_options_string = cl.minimum_runnable_options.collect do |o|
+            "#{o} #{cl.send(o).respec_string}" unless cl.send(o).nil?
           end
-          out << "end"
+          out << <<-EOE
+cloud :#{cl.name} do
+  #{minimum_runnable_options_string.join("\n")}
+end
+          EOE
         end
-      end.join("\n")
+        out << "end"
+      end
+      out.join("\n")
     end
     
     def self.save!(to_file=true)
-      write_to_file_in_storage_directory(Base.default_specfile_name, for_save_string) if to_file
+      write_to_file_in_storage_directory(Default.default_specfile_name, for_save_string) if to_file
       for_save_string
     end
     

data/lib/poolparty/poolparty/service.rb

@@ -0,0 +1,44 @@
+module PoolParty
+  
+  class Service < PoolPartyBaseClass
+    
+    include PoolParty::DependencyResolverCloudExtensions
+    
+    def initialize(o={}, &block)
+      super(o, &block)
+    end
+    
+    def to_properties_hash
+      { :pp_type => "plugin", :options => options, 
+        :name => self.class.to_s.top_level_class,
+        :resources => ordered_resources.map {|a| a.to_properties_hash }}
+    end
+    
+    def cloud
+      2.upto(context_stack.size) do |i|
+        return ::PoolParty.context_stack[-i] if ::PoolParty.context_stack[-i].is_a?(PoolParty::Cloud::Cloud)
+      end
+      nil
+    end
+    
+    def self.add_has_and_does_not_have_methods_for(typ=:file)
+      lowercase_class_name = typ.to_s.top_level_class.downcase
+      
+      meth = <<-EOM
+        def __#{lowercase_class_name}(opts={}, &block)
+          i = PoolParty::#{lowercase_class_name.camelcase}Class.new(opts, &block)
+          plugin_store << i if respond_to?(:plugin_store)
+          i
+        end
+        alias :#{lowercase_class_name} :__#{lowercase_class_name}
+      EOM
+      
+      PoolParty::PoolPartyBaseClass.module_eval meth
+      PoolParty::PoolPartyBaseClass.add_has_and_does_not_have_methods_for(lowercase_class_name.to_sym)
+    end
+    
+  end
+  
+end
+
+Dir["#{::File.dirname(__FILE__)}/../services/*.rb"].each {|lib| require "#{lib}"}

data/lib/poolparty/poolparty/template.rb

@@ -0,0 +1,27 @@
+require "ostruct"
+require "erb"
+
+module PoolParty
+  class Template
+        
+    def self.compile_string(string, opts={})
+      vars = OpenStruct.new opts
+      handle_render(string, vars, (opts.delete(:render) || :erb))
+    end
+    
+    def self.compile_file(file, opts={})
+      content = open(file).read
+      compile_string(content, opts)
+    end
+    
+    def self.handle_render(string, vars, renderer)
+      case renderer
+      when :haml
+        nil
+      else
+        ERB.new(string).result(vars.send(:binding))
+      end
+    end
+    
+  end
+end

data/lib/poolparty/provision/boot_strapper.rb

@@ -0,0 +1,164 @@
+=begin rdoc
+  BootStrapper is contains the basic files that need to be uploaded to a new instance and the first commands that are run to set up a base PoolParty enviornment.  This includes things like ensuring that ruby, rubygems, and poolparty are installed, and then start the monitor.
+=end
+
+require "#{::File.dirname(__FILE__)}/../net/remoter/connections"
+
+# Provide a very simple provisioner with as few dependencies as possible
+module PoolParty
+  module Provision
+  
+    class BootStrapper
+      include ::PoolParty::Remote
+      
+      # List of gems that are default to install
+      def self.gem_list
+        @gem_list ||= %w( logging
+                          rake
+                          xml-simple
+                          net-ssh
+                          net-sftp
+                          net-scp
+                          net-ssh-gateway
+                          highline
+                          json
+                          activesupport
+                          grempe-amazon-ec2
+                          ohai
+                          chef
+                          auser-dslify
+                          auser-parenting
+                          adamwiggins-rest-client
+                          rack
+                          thin
+                        )
+      end
+
+      # Default options for the boot_strapper
+      @defaults = ::PoolParty::Default.default_options.merge({
+        :full_keypair_path   => "#{ENV["AWS_KEYPAIR_NAME"]}" || "~/.ssh/id_rsa",
+        :installer           => 'apt-get',
+        :dependency_resolver => 'chef'
+      })
+      class <<self; attr_reader :defaults; end
+      
+      # In case the method is being called on ourself, let's check the 
+      # defaults hash to see if it's available there
+      def method_missing(m,*a,&block)
+        if self.class.defaults.has_key?(m) 
+          self.class.defaults[m]
+        elsif @cloud
+          @cloud.send m, *a, &block
+        else
+          super
+        end
+      end
+      
+      def initialize(host, opts={}, &block)        
+        self.class.defaults.merge(opts).to_instance_variables(self)
+        @target_host = host
+        @cloud = opts[:cloud]
+                
+        instance_eval &block if block
+        @cloud.call_before_bootstrap_callbacks if @cloud
+        
+        default_commands
+        dputs "Starting bootstrapping process on #{host}"
+        execute!
+        
+        @cloud.call_after_bootstrap_callbacks if @cloud
+        after_bootstrap
+        dputs "Bootstrapping complete on #{host}"
+      end
+      
+      def self.class_commands
+        @class_commands ||= []
+      end
+        
+      # Collect all the bootstrap files that will be uploaded to the remote instances
+      def pack_the_dependencies
+        # Add the keypair to the instance... shudder
+        ::Suitcase::Zipper.add(keypair, "keys")
+        
+        # Use the locally built poolparty gem if it is availabl
+        if edge_pp_gem = Dir["#{Default.vendor_path}/../pkg/*poolparty*gem"].pop
+          puts "using edge poolparty: #{::File.expand_path(edge_pp_gem)}"
+          ::Suitcase::Zipper.add(edge_pp_gem, 'gems')
+        else
+          vputs "using gem auser-poolparty. use rake build to use edge"
+          self.class.gem_list << 'auser-poolparty'
+        end
+        # Add the gems to the suitcase
+        puts "Adding default gem dependencies"
+        ::Suitcase::Zipper.gems self.class.gem_list, "#{Default.tmp_path}/trash/dependencies"
+
+        ::Suitcase::Zipper.packages( "http://rubyforge.org/frs/download.php/45905/rubygems-1.3.1.tgz",
+                 "#{Default.tmp_path}/trash/dependencies/packages")
+        # ::Suitcase::Zipper.add("templates/")
+        
+        ::Suitcase::Zipper.add("#{::File.dirname(__FILE__)}/../templates/monitor.ru", "/etc/poolparty/")
+        ::Suitcase::Zipper.add("#{::File.dirname(__FILE__)}/../templates/monitor.god", "/etc/poolparty/")
+                
+        ::Suitcase::Zipper.add("#{Default.tmp_path}/trash/dependencies/cache", "gems")        
+        
+        ::Suitcase::Zipper.add("#{::File.join(File.dirname(__FILE__), '..', 'templates', 'gemrc_template' )}", "etc/poolparty")
+        
+        instances = @cloud.nodes(:status => "running") + [@cloud.started_instance]
+        ::Suitcase::Zipper.add_content_as(
+          {:instances => instances.flatten.compact}.to_json, 
+          "neighborhood.json", "/etc/poolparty")
+        
+        ::Suitcase::Zipper.build_dir!("#{Default.tmp_path}/dependencies")
+        
+        ::Suitcase::Zipper.flush!
+        
+        # ::FileUtils.rm_rf "#{Default.tmp_path}/trash"
+      end
+  
+      # The commands to setup a PoolParty enviornment
+      def default_commands
+        pack_the_dependencies
+        ::FileUtils.rm_rf "#{Default.tmp_path}/dependencies/gems/cache"
+        rsync "#{Default.tmp_path}/dependencies", '/var/poolparty'
+        
+        commands << [
+          "mkdir -p /etc/poolparty",
+          "mkdir -p /var/log/poolparty",
+          "groupadd -f poolparty",
+          # "useradd poolparty  --home-dir /var/poolparty  --groups poolparty  --create-home",
+          'cd /var/poolparty/dependencies',
+          "cp /var/poolparty/dependencies/etc/poolparty/gemrc_template /etc/poolparty",          
+          "#{installer} update",
+          "#{installer} install -y ruby ruby1.8-dev libopenssl-ruby1.8 build-essential wget",  #optional, but nice to have
+          "tar -zxvf packages/rubygems-1.3.1.tgz",
+          "cd rubygems-1.3.1",
+          "ruby setup.rb --no-ri --no-rdoc",
+          "ln -sfv /usr/bin/gem1.8 /usr/bin/gem", #TODO: check if this is really needed
+          "cd ../ && rm -rf rubygems-1.3.1*",
+          "gem source --add http://gems.github.com",
+          "cd /var/poolparty/dependencies/gems/",
+          "gem install --no-rdoc --no-ri -y *.gem",
+          "cd /var/poolparty/dependencies",
+          "cp /var/poolparty/dependencies/etc/poolparty/* /etc/poolparty/",
+          'touch /var/poolparty/POOLPARTY.PROGRESS',
+          "mkdir -p /root/.ssh",
+          "cp /var/poolparty/dependencies/keys/* /root/.ssh/",
+          "chmod 600 /root/.ssh/#{::File.basename(@cloud.keypair.full_filepath)}",
+          # "god -c /etc/poolparty/monitor.god",
+          "mkdir -p /var/log/poolparty/",
+          "thin -R /etc/poolparty/monitor.ru -p 8642 --pid /var/run/stats_monitor.pid --daemon -l /var/log/poolparty/monitor.log start 2>/dev/null",
+          'echo "bootstrap" >> /var/poolparty/POOLPARTY.PROGRESS']
+        commands << self.class.class_commands unless self.class.class_commands.empty?
+      end
+      
+      def after_bootstrap
+        # thin_cmd = "thin -R /etc/poolparty/monitor.ru start -p 8642 --daemonize --pid /var/run/poolparty/monitor.pid --log /var/log/poolparty/monitor.log --environment production --chdir /var/poolparty" #TODO --user poolparty --group poolparty
+        # vputs "thin_cmd = #{thin_cmd}"
+        # curl_put = "curl -i -XPUT -d'{}' http://localhost:8642/stats_monitor"
+        # execute! [ thin_cmd, "sleep 10", curl_put  ] 
+        # execute! ["sleep 5", curl_put]
+      end
+    end
+    
+  end
+end