poolparty 0.2.69 → 0.2.84

data/lib/poolparty/net/remoter.rb

@@ -2,14 +2,17 @@
   This module is included by the remote module and defines the remoting methods
   that the clouds can use to rsync or run remote commands
 =end
-require File.dirname(__FILE__) + "/../helpers/provisioner_base"
-
 module PoolParty
   module Remote
     module Remoter
-      def rsync_storage_files_to_command(remote_instance)        
+      def rsync_storage_files_to_command(remote_instance)
+        #TODO: rsync_to_command("#{Base.storage_directory}/", Base.remote_storage_path, remote_storage_path) if remote_instance
         "#{rsync_command} #{Base.storage_directory}/ #{remote_instance.ip}:#{Base.remote_storage_path}" if remote_instance
       end
+      # rsync a file to a node.  By default to the master node.
+      def rsync_to_command(source, target=source, remote_instance=master)
+        "#{rsync_command} #{source} #{remote_instance.ip}:#{target}"
+      end
       def run_command_on_command(cmd="ls -l", remote_instance=nil)
         vputs "Running #{cmd} on #{remote_instance.name == %x[hostname].chomp ? "self (master)" : "#{remote_instance.name}"}"
         remote_instance.name == %x[hostname].chomp ? %x[#{cmd}] : "#{ssh_command(remote_instance)} '#{cmd}'"
@@ -25,11 +28,12 @@ module PoolParty
       # Includes StrictHostKeyChecking to no
       # Ssh with the user in Base
       # And including the keypair_path
+      # "-l '#{Base.user}'", 
       def ssh_array
-        ["-o StrictHostKeyChecking=no", "-l '#{Base.user}'", '-i "'+full_keypair_path+'"']
+        ["-o StrictHostKeyChecking=no", "-l #{Base.user}", '-i "'+full_keypair_path+'"']
       end
       def rsync_command
-        "rsync -azP --exclude cache -e '#{ssh_string}'"
+        "rsync -azP --exclude cache -e '#{ssh_string} -l #{Base.user}'"
       end
       def remote_ssh_array
         ["-o StrictHostKeyChecking=no", "-l '#{Base.user}'", '-i "'+remote_keypair_path+'"']
@@ -40,6 +44,13 @@ module PoolParty
       def remote_rsync_command
         "rsync -azP --exclude cache -e '#{remote_ssh_string}'"
       end
+      
+      
+      # def scp_command(source, dest=target, remote_instance=master)
+      #   #TODO: check if source is Directory and add -r if it is
+      #   "scp #{source} #{remote_instance.ip}:#{dest} #{ssh_array.join(' ')}"
+      # end
+      
       # Get the names of the nodes. Mainly used for puppet templating
       def list_of_node_names(options={})
         list_of_running_instances.collect {|ri| ri.name }
@@ -71,10 +82,22 @@ module PoolParty
       def minimum_number_of_instances_are_running?
         list_of_running_instances.size >= minimum_instances.to_i
       end
+      # Are the minimum number of instances NOT running?
+      def minimum_number_of_instances_are_not_running?
+        !(minimum_number_of_instances_are_running?)
+      end
       # Can we shutdown an instance?
       def can_shutdown_an_instance?
         list_of_running_instances.size > minimum_instances.to_i
       end
+      # Are too few instances running?
+      def are_too_few_instances_running?
+        list_of_running_instances.size < minimum_instances.to_i
+      end
+      # Are there more instances than allowed?
+      def are_too_many_instances_running?
+        list_of_running_instances.size > maximum_instances.to_i
+      end
       # Request to launch a number of instances
       def request_launch_new_instances(num=1)
         out = []
@@ -82,11 +105,15 @@ module PoolParty
         out
       end
       def request_launch_master_instance
-        inst = launch_new_instance!
+        @inst = launch_new_instance!
         wait "5.seconds"
-        when_no_pending_instances {after_launch_master(inst)}
+        when_no_pending_instances do
+          vputs "Master has launched"
+          reset!
+          after_launch_master(@inst)
+        end
       end
-      def after_launch_master(h={})
+      def after_launch_master(inst=nil)
         vputs "After launch master in remoter"
       end
       # Let's terminate an instance that is not the master instance
@@ -161,13 +188,14 @@ module PoolParty
           last_instances = nonmaster_nonterminated_instances[(@num_instances - (num))..(@num_instances)]
           last_instances.each do |inst|
             vputs "Provision slave: #{inst}"
-            hide_output {PoolParty::Provisioner.process_clean_reconfigure_for!(inst, self)}
-            PoolParty::Provisioner.provision_slave(inst, self, false) unless inst.master? rescue vputs "Error"
-            hide_output {PoolParty::Provisioner.process_clean_reconfigure_for!(inst, self)}
+            # hide_output {PoolParty::Provisioner.process_clean_reconfigure_for!(inst, self)}
+            # PoolParty::Provisioner.provision_slave(inst, self, false) unless inst.master? rescue vputs "Error"
+            verbose ? provisioner_for(inst).install(testing) : hide_output { provisioner_for(inst).install(testing) }
+            # hide_output {PoolParty::Provisioner.process_clean_reconfigure_for!(inst, self)}
             # cmd = ". /etc/profile && cloud-provision -i #{inst.name.gsub(/node/, '')} &"
             # vputs "Provision slave with command #{cmd}"
           end
-          PoolParty::Provisioner.reconfigure_master(self)
+          # PoolParty::Provisioner.reconfigure_master(self)
         end
       end
       # Launch the master and let the master handle the starting of the cloud
@@ -177,7 +205,7 @@ module PoolParty
       # Then wait for the master to launch
       def launch_and_configure_master!(testing=false)
         vputs "Requesting to launch new instance"
-        logger.debug "Launching master"
+        log.debug "Launching master"
         request_launch_master_instance if list_of_pending_instances.size.zero? && can_start_a_new_instance? && !is_master_running? && !testing
         reset!
         unless testing
@@ -188,23 +216,36 @@ module PoolParty
             vputs ""
             vputs "Provisioning master..."
             # cleanup_storage_directory
-            verbose ? Provisioner.provision_master(self, testing) : hide_output { Provisioner.provision_master(self, testing) }
-            verbose ? Provisioner.clear_master_ssl_certs(self, testing) : hide_output { Provisioner.clear_master_ssl_certs(self, testing) }
+            @provisioner = PoolParty::Provisioner::Capistrano.new(master, self, :ubuntu)
+            verbose ? @provisioner.install(testing) : hide_output { @provisioner.install(testing) }
           
             after_launched
           end
         end
       end
+      def list_of_nodes_exceeding_minimum_runtime
+        list_of_running_instances.reject{|i| i.elapsed_runtime < minimum_runtime}
+      end
+      def are_any_nodes_exceeding_minimum_runtime?
+        !list_of_nodes_exceeding_minimum_runtime.blank?
+      end
       def is_master_running?
         !list_of_running_instances.select {|a| a.name == "master"}.first.nil?
       end
       # Stub method for the time being to handle expansion of the cloud
       def should_expand_cloud?(force=false)
-        valid_rules?(:expand_when) || force || false
+        (are_too_few_instances_running? || are_expansion_rules_valid? ) || force || false
+      end
+      def are_expansion_rules_valid?
+        valid_rules?(:expand_when)
       end
       # Stub method for the time being to handle the contraction of the cloud
       def should_contract_cloud?(force=false)
-        valid_rules?(:contract_when) || force || false
+        return true if force
+        ((are_any_nodes_exceeding_minimum_runtime? and are_too_many_instances_running?) || are_contraction_rules_valid?) || false
+      end
+      def are_contraction_rules_valid?
+        valid_rules?(:contract_when)
       end
       # Expand the cloud
       # If we can start a new instance and the load requires us to expand
@@ -229,12 +270,10 @@ module PoolParty
       # If we can shutdown an instnace and the load allows us to contract
       # the cloud, then we should request_termination_of_non_master_instance
       def contract_cloud_if_necessary(force=false)
-        if can_shutdown_an_instance?          
-          if should_contract_cloud?(force)
-            vputs "Shrinking the cloud by 1"
-            before_shutdown
-            request_termination_of_non_master_instance
-          end
+        if can_shutdown_an_instance? && should_contract_cloud?(force)
+          vputs "Shrinking the cloud by 1"
+          before_shutdown
+          request_termination_of_non_master_instance
         end
       end
       
@@ -250,6 +289,13 @@ module PoolParty
       def before_shutdown
       end
       
+      # Rsync a file or directory to a node.  Rsync to master by default
+      def rsync_to(source, target=source, num=0)
+        str = "#{rsync_to_command(source, target, get_instance_by_number( num ))}"
+        vputs "Running: #{str}"
+        verbose ?  Kernel.system(str) : hide_output {Kernel.system str}
+      end
+      
       # Rsync command to the instance
       def rsync_storage_files_to(instance=nil)
         hide_output {Kernel.system "#{rsync_storage_files_to_command(instance)}" if instance}
@@ -262,7 +308,9 @@ module PoolParty
       
       # Ssh into the instance given
       def ssh_into(instance=nil)
-        Kernel.system "#{ssh_command(instance)}" if instance
+        cmd = "#{ssh_command(instance)}"
+        vputs "Running #{cmd}"
+        Kernel.system cmd if instance
       end
       # Find the instance by the number given
       # and then ssh into the instance

data/lib/poolparty/net/remoter_base.rb

@@ -88,6 +88,9 @@ module PoolParty
         name = (i.zero? ? "master" : "node#{i}")
         list.select {|i| i.name == name }.first
       end
+      # A callback before the configuration task takes place
+      def before_configuration_tasks        
+      end
       def remote_instances_list        
         @containing_cloud = self
         # puts "> #{@containing_cloud} #{@describe_instances.nil?}"
@@ -137,6 +140,13 @@ module PoolParty
       # Callback after loaded
       def loaded_remoter_base        
       end
+      
+      # Custom minimum runnable options
+      # Extend the minimum runnable options that are necessary
+      # for poolparty to run on the remote base
+      def custom_minimum_runnable_options
+        []
+      end
             
       # Custom installation tasks
       # Allow the remoter bases to attach their own tasks on the 

data/lib/poolparty/plugins/deploydirectory.rb

@@ -18,17 +18,18 @@ module PoolParty
             
       def package_directory
         path = ::File.join( Base.tmp_path, "#{::File.basename(from_dir)}.tar.gz" )
-        archive_name = "#{name.dir_safe}.tar.gz"
+        archive_name = "#{::File.basename(name).dir_safe}.tar.gz"
         cmd = "cd #{::File.expand_path(from_dir)} && tar -czf #{archive_name} . && mv #{archive_name} #{Base.tmp_path}"
-        `#{cmd}` unless testing
+        Kernel.system(cmd) unless testing
       end
       
       def unpack_directory
         execute_on_master do
           has_exec({:name => "deploy-directory-#{name}", :requires => get_directory("#{cwd}"), :cwd => cwd}) do
             #  && rm #{Base.tmp_path}/#{parent.name.dir_safe}.tar.gz
-            command "cd #{cwd}; tar -zxf #{Base.remote_storage_path}/#{name.dir_safe}.tar.gz; rm #{Base.remote_storage_path}/#{name.dir_safe}.tar.gz"
-            onlyif "test -f #{Base.remote_storage_path}/#{name.dir_safe}.tar.gz"
+            archive_name = "#{::File.basename(name).dir_safe}.tar.gz"
+            command "cd #{cwd}; tar -zxf #{Base.remote_storage_path}/#{archive_name}; rm #{Base.remote_storage_path}/#{archive_name}; chown #{owner} #{::File.basename(name).dir_safe}"
+            onlyif "test -f #{Base.remote_storage_path}/#{archive_name}"
           end
         end
       end
@@ -45,7 +46,11 @@ module PoolParty
       
       def to(dir)
         cwd dir
-        has_directory(:name => "#{dir}", :requires => get_directory("#{::File.dirname(dir)}"))
+        name dir
+        has_directory(:name => "#{dir}", 
+                      :requires => get_directory("#{::File.dirname(dir)}"), 
+                      :owner => owner,
+                      :mode => mode)
       end
       
       # Since git is not a native type, we have to say which core resource

data/lib/poolparty/plugins/git.rb

@@ -0,0 +1,51 @@
+module PoolParty    
+  class GitResource
+        
+    virtual_resource(:git) do
+      
+      def loaded(opts={}, parent=self)
+        has_git_repos
+      end
+            
+      def has_git_repos
+        has_package(:name => "git-core")
+        has_exec({:name => key, :requires => [get_directory("#{working_dir}"), get_package("git-core")] }) do
+          command requires_user ? "git clone #{requires_user}@#{source} #{working_dir}" : "cd #{working_dir} && git clone #{source}"
+          cwd "#{working_dir if working_dir}"
+          creates creates_dir
+        end
+        has_exec(:name => "update-#{name}") do
+          cwd ::File.dirname( creates_dir )
+          command "git pull"
+        end                
+      end
+      
+      def at(dir)
+        working_dir dir
+        has_directory(:name => "#{dir}", :requires => get_directory("#{::File.dirname(dir)}"))
+      end
+      
+      def to(dir)
+        at(dir)
+      end
+      
+      def creates_dir
+        "#{::File.join( working_dir, ::File.basename(source, ::File.extname(source)) )}/.git"
+      end
+      
+      # Since git is not a native type, we have to say which core resource
+      # it is using to be able to require it
+      def class_type_name
+        "exec"
+      end
+      
+      # Because we are requiring an exec, instead of a built-in package of the git, we have to overload
+      # the to_s method and prepend it with the same name as above
+      def key
+        "git-#{name}"
+      end
+      
+    end
+    
+  end
+end

data/lib/poolparty/{pool → poolparty}/base.rb

@@ -20,15 +20,17 @@ module PoolParty
       :template_directory => "templates",
       :template_path => "/var/lib/puppet/templates",
       :module_path => "/etc/puppet/modules/poolparty",
-      :default_specfile_name => "pool.spec",
-      :default_project_specfile_name => "spec/pool.spec",
+      :default_specfile_name => "clouds.pool",
+      :default_project_specfile_name => "spec/clouds.pool",
       :port => "80",
       :forwarding_port => "8080",
       :proxy_mode => "http",
       :messenger_client_port => 7050,
+      :minimum_runtime  => 3000, #50.minutes in seconds
       # EC2 Options
       :ami => "ami-1cd73375",
       :size => 'm1.small', # must be 'm1.small', 'm1.large', 'm1.xlarge', 'c1.medium', or 'c1.xlarge'
+      :availabilty_zone => "us-east-1a",
       :security_group => ["default"],
       # Options that should not be touched pretty much ever
       :manifest_path => "/etc/puppet/manifests"

data/lib/poolparty/{pool → poolparty}/cloud.rb

@@ -24,6 +24,7 @@ module PoolParty
       include PrettyPrinter
       include Configurable
       include CloudResourcer
+      include Provisioner
       # extend CloudResourcer
       # Net methods      
       include Remote
@@ -38,6 +39,8 @@ module PoolParty
         :secret_access_key => Base.secret_access_key,
         :ec2_dir => ENV["EC2_HOME"],
         :keypair => (ENV["KEYPAIR_NAME"].nil? || ENV["KEYPAIR_NAME"].empty?) ? nil : ENV["KEYPAIR_NAME"],
+        :minimum_runtime => Base.minimum_runtime,
+        :user => Base.user,
         :ami => 'ami-44bd592d'
       })
       
@@ -45,15 +48,18 @@ module PoolParty
         @cloud_name = name
         @cloud_name.freeze
                 
-        plugin_directory "#{::Dir.pwd}/plugins"
+        plugin_directory
                 
         p = pare.is_a?(PoolParty::Pool::Pool) ? pare : nil
-        run_setup(p, &block)
+        store_block(&block)
+        run_setup(p, &block)        
         
         # set_parent(parent) if parent && !@parent
         # self.run_in_context parent, &block if block
         setup_defaults
-        reset_remoter_base!        
+        # realize_plugins!
+        # reset! # reset the clouds
+        # reset_remoter_base!
       end
       
       def setup_defaults
@@ -76,7 +82,7 @@ module PoolParty
       def generate_keypair(*args)
         options[:keypair] = "#{parent && parent.is_a?(PoolParty::Pool::Pool) ? parent.name : "poolparty"}_#{name}" unless has_keypair?
       end
-      
+            
       # Prepare to send the new configuration to the instances
       # First, let's make sure that our base directory is made
       # Then copy the templates that have no other reference in
@@ -94,6 +100,8 @@ module PoolParty
         Script.save!(self)
         # not my favorite...
         copy_ssh_key
+        write_unique_cookie
+        before_configuration_tasks
       end
       
       # Copy the ssh keys to the storage directory in preparation for
@@ -108,6 +116,20 @@ module PoolParty
         Base.store_keys_in_file_for(self)
       end
       
+      # Let's write the cookie into the tmp path
+      def write_unique_cookie
+        write_to_file_in_storage_directory("cookie") do
+          generate_unique_cookie_string
+        end
+      end
+      
+      # Generate a unique cookie string so that our erlang modules can 
+      # talk to each other safely. This is based off the keypair
+      # and the name of the cloud
+      def generate_unique_cookie_string
+        Digest::SHA256.hexdigest("#{full_keypair_name}#{name}")
+      end
+      
       # Build the new poolparty manifest
       # Wrapping all of these requirements into the one 
       # poolparty class.
@@ -125,7 +147,7 @@ module PoolParty
       end      
       
       def copy_misc_templates
-        ["namespaceauth.conf"].each do |f|
+        ["namespaceauth.conf", "puppet.conf", "gem"].each do |f|
           copy_file_to_storage_directory(::File.join(::File.dirname(__FILE__), "..", "templates", f))
         end
       end
@@ -197,10 +219,10 @@ module PoolParty
       # they need a few options to run, these are the required options
       # to be saved on the remote "master" machine
       def minimum_runnable_options
-        [
-          :keypair, :minimum_instances, :maximum_instances, :ami, :security_group,
+        ([
+          :keypair, :minimum_instances, :maximum_instances,
           :expand_when, :contract_when, :set_master_ip_to
-        ]
+        ]<< custom_minimum_runnable_options).flatten
       end
       
       # Add all the poolparty requirements here
@@ -209,12 +231,12 @@ module PoolParty
       # Also note that there is no block associated. This is because we have written
       # all that is necessary in a method called enable
       # which is called when there is no block
-      def add_poolparty_base_requirements        
+      def add_poolparty_base_requirements
         heartbeat
         haproxy
         ruby
         poolparty_base_packages
-        realize_plugins!
+        realize_plugins!(true) # Force realizing of the plugins
       end
       
       def other_clouds

data/lib/poolparty/{pool → poolparty}/plugin_model.rb

@@ -4,7 +4,7 @@ module PoolParty
   module PluginModel
     
     def plugin(name=:plugin, cloud=nil, &block)
-      plugins.has_key?(name) ? plugins[name] : (plugins[name] = PluginModel.new(name, cloud, &block))
+      plugins.has_key?(name) ? plugins[name] : (plugins[name] = PluginModel.new(name, &block))
     end
     alias_method :register_plugin, :plugin
     
@@ -18,15 +18,15 @@ module PoolParty
       include Configurable
       include PrettyPrinter      
       
-      def initialize(name,cld,&block)
+      def initialize(name,&block)
         @name = name
         # @parent = cld
         class_string_name = "#{name}"
         
         # Create the class to evaluate the plugin on the implemented call
-        klass = class_string_name.class_constant(PoolParty::Plugin::Plugin)
+        @klass = klass = class_string_name.class_constant(PoolParty::Plugin::Plugin)
         mod = class_string_name.module_constant(&block)
-
+        
         klass.send :include, mod
         
         # Store the name of the class for pretty printing later

data/lib/poolparty/{pool → poolparty}/pool.rb

@@ -35,11 +35,10 @@ module PoolParty
       
       def initialize(name,&block)
         setup_defaults
-        
         @pool_name = name
         @pool_name.freeze
         # run_in_context &block if block
-        run_setup(self, &block)
+        run_setup(self, &block)        
       end
       
       def name
@@ -48,6 +47,7 @@ module PoolParty
       
       def setup_defaults
         plugin_directory "#{::File.dirname(pool_specfile ? pool_specfile : Dir.pwd)}/plugins"
+        PoolParty::Extra::Deployments.include_deployments "#{Dir.pwd}/deployments"
       end
             
       # This is where the entire process starts

data/lib/poolparty/{pool → poolparty}/resource.rb

@@ -18,8 +18,9 @@ module PoolParty
     end
     
     def add_resource(type, opts={}, parent=self, &block)
-      if in_a_resource_store?(type, opts[:name])
-        @res = get_resource(type, opts[:name], parent)
+      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
@@ -85,13 +86,16 @@ module PoolParty
       
       include CloudResourcer
       include Configurable
+      # 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
       
       extend PoolParty::Resources
       include PoolParty::Resources
       
       def self.inherited(subclass)
         subclass = subclass.to_s.split("::")[-1] if subclass.to_s.index("::")
-        lowercase_class_name = subclass.to_s.underscore
+        lowercase_class_name = subclass.to_s.underscore.downcase || subclass.downcase
         
         # Add add resource method to the Resources module
         unless PoolParty::Resources.respond_to?(lowercase_class_name.to_sym)          
@@ -99,8 +103,14 @@ module PoolParty
             def #{lowercase_class_name}(opts={}, parent=self, &blk)
               add_resource(:#{lowercase_class_name}, opts, parent, &blk)
             end
-            def get_#{lowercase_class_name}(name)              
-              get_resource(:#{lowercase_class_name}, name) if in_a_resource_store?(:#{lowercase_class_name}, name)
+            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)
+              res
             end
           EOE
           PoolParty::Resources.module_eval method
@@ -185,7 +195,7 @@ module PoolParty
       end
       # This way we can subclass resources without worry
       def class_type_name
-        self.class.to_s.top_level_class.underscore
+        self.class.to_s.top_level_class.underscore.downcase
       end
       def self.custom_function(str)
         custom_functions << str
@@ -215,7 +225,7 @@ module PoolParty
           :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
+          :binary, :status, :start, :stop, :restart, :pattern, :recurse, :home
         ]
       end
       def key
@@ -239,21 +249,20 @@ module PoolParty
       def get_modified_options
         unless @modified_options
           if options
-            opts = options.inject({}) do |sum,h| 
+            opts = options.inject({}) do |sum,h|
               sum.merge!({h[0].to_sym => ((h[1].nil?) ? self.send(h[0].to_sym) : h[1]) })
             end
           else
             opts = {}
           end
           @full_allowed_options ||= allowed_options.reject {|ele| disallowed_options.include?(ele) }
-          @modified_options = opts.reject {|k,v| !@full_allowed_options.include?(k) }
+          @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]
+          end
         end
         @modified_options
       end
-      
-      # 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
     end
     
     # Adds two methods to the module
@@ -269,13 +278,22 @@ module PoolParty
     def self.add_has_and_does_not_have_methods_for(type=:file)
       module_eval <<-EOE
         def has_#{type}(opts={}, parent=self, &block)
-          #{type}(#{type == :exec ? "opts" : "{:is_present => ''}.merge(opts)"}, parent, &block)
+          #{type}(handle_option_values(opts).merge(:ensures => "present"), parent, &block)
         end
         def does_not_have_#{type}(opts={}, parent=self, &block)
-          #{type}(#{type == :exec ? "opts" : "{:is_absent => ''}.merge(opts)"}, parent, &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

data/lib/poolparty/{pool → poolparty}/resources/class_package.rb

@@ -22,7 +22,7 @@ module PoolParty
     
     # Wrap all the resources into a class package from 
     def classpackage_with_self(parent=self, &block)
-      name = (parent.options.name || Classpackage.name(parent).to_s).sanitize
+      name = (parent && parent.options.name || Classpackage.name(parent).to_s).sanitize
       if in_global_classpackages?(name)
         returning get_from_global_classpackage_store(name) do |cls|
           cls.run_in_context(parent, &block) if block
@@ -45,7 +45,7 @@ module PoolParty
         store_into_global_classpackage_store(@@cp)
       end      
       return @@cp
-      @@parent_resources = nil
+      @@parent_resources = @@cp = nil
     end
                 
     class Classpackage < Resource
@@ -95,7 +95,7 @@ module PoolParty
         false
       end
       
-      def self.name(parent=nil)
+      def self.name(parent=self)
         "custom_#{parent ? parent.object_id.to_s : "parent"}"
       end
 

data/lib/poolparty/{pool → poolparty}/resources/directory.rb

@@ -4,15 +4,18 @@ module PoolParty
     class Directory < Resource
             
       default_options({
-        :ensure => "directory",
-        :mode => 644,
-        :owner => "#{Base.user}"
+        :mode => 644
+        # :owner => "#{Base.user}"
       })
       
       def class_type_name
         "file"
       end
       
+      def ensure
+        "directory"
+      end
+      
       def present
         'directory'
       end