chef 0.8.16 → 0.9.0.a3

data/lib/chef/provider/package/yum.rb

@@ -106,9 +106,9 @@ class Chef
           end
         end
 
-        def initialize(node, new_resource, collection=nil, definitions=nil, cookbook_loader=nil)
+        def initialize(new_resource, run_context)
           @yum = YumCache.instance
-          super(node, new_resource, collection, definitions, cookbook_loader)
+          super
         end
       
         def load_current_resource

data/lib/chef/provider/package/zypper.rb

@@ -32,8 +32,9 @@ class Chef
           @current_resource.package_name(@new_resource.package_name)
 
           is_installed=false
-          version=''
           is_out_of_date=false
+          version=''
+          oud_version=''
           Chef::Log.debug("Checking zypper for #{@new_resource.package_name}")
           status = popen4("zypper info #{@new_resource.package_name}") do |pid, stdin, stdout, stderr|
             stdout.each do |line|

data/lib/chef/provider/remote_directory.rb

@@ -18,8 +18,8 @@
 
 require 'chef/provider/file'
 require 'chef/provider/directory'
-require 'chef/rest'
-require 'chef/mixin/find_preferred_file'
+#require 'chef/rest'
+#require 'chef/mixin/find_preferred_file'
 require 'chef/resource/directory'
 require 'chef/resource/remote_file'
 require 'chef/platform'
@@ -32,30 +32,29 @@ class Chef
   class Provider
     class RemoteDirectory < Chef::Provider::Directory
 
-      include ::Chef::Mixin::FindPreferredFile
-      
       def action_create
         super
-        do_recursive
-      end
-    
-      protected
-      
-      def do_recursive
-        if Chef::Config[:solo]
-          Chef::Log.debug("Doing a local recursive directory copy for #{@new_resource}")
-        else
-          Chef::Log.debug("Doing a remote recursive directory transfer for #{@new_resource}")
-        end
+        Chef::Log.debug("Doing a remote recursive directory transfer for #{@new_resource}")
           
-        existing_files = Set.new Dir[::File.join(@new_resource.path, '**', '*')]
+        files_to_purge = Set.new Dir[::File.join(@new_resource.path, '**', '*')]
 
-        files_to_transfer.each do |remote_file_source|
-          fetch_remote_file(remote_file_source)
-          existing_files.delete(::File.join(@new_resource.path, remote_file_source))
+        files_to_transfer.each do |cookbook_file_relative_path|
+          create_cookbook_file(cookbook_file_relative_path)
+          files_to_purge.delete(::File.dirname(::File.join(@new_resource.path, cookbook_file_relative_path)))
+          files_to_purge.delete(::File.join(@new_resource.path, cookbook_file_relative_path))
         end
+        purge_unmanaged_files(files_to_purge)
+      end
+
+      def action_create_if_missing
+        raise Chef::Exceptions::UnsupportedAction, "Remote Directories do not support create_if_missing."
+      end
+
+      protected
+
+      def purge_unmanaged_files(unmanaged_files)
         if @new_resource.purge
-          existing_files.sort { |a,b| b <=> a }.each do |f|
+          unmanaged_files.sort.reverse.each do |f|
             if ::File.directory?(f)
               Chef::Log.debug("Removing directory #{f}")
               Dir::rmdir(f)
@@ -66,89 +65,67 @@ class Chef
           end
         end
       end
-      
+
       def files_to_transfer
-        file_list = Chef::Config[:solo] ? generate_solo_file_list : generate_client_file_list
-        Chef::Log.debug("Generated file manifest for #{@new_resource}:\n#{file_list.join("\n")}")
-        file_list
+        cookbook = run_context.cookbook_collection[resource_cookbook]
+        files = cookbook.relative_filenames_in_preferred_directory(node, :files, @new_resource.source)
+        files.sort.reverse
       end
       
-      def generate_solo_file_list
-        # Pulled from chef-server-slice files controller
-        directory = find_preferred_file(
-          @new_resource.cookbook_name, 
-          :remote_file, 
-          @new_resource.source, 
-          @node[:fqdn],
-          @node[:platform],
-          @node[:platform_version]
-        )
-
-        unless (directory && ::File.directory?(directory))
-          raise NotFound, "Cannot find a suitable directory"
+      def directory_root_in_cookbook_cache
+        @directory_root_in_cookbook_cache ||= begin
+          cookbook = run_context.cookbook_collection[resource_cookbook]
+          cookbook.preferred_filename_on_disk_location(node, :files, @new_resource.source, @new_resource.path)
         end
-
-        file_list = Array.new
-        Dir[::File.join(directory, '**', '*')].sort.reverse.select do |file|
-          unless ::File.directory?(file)
-            file_list << file[/^#{directory}\/(.+)$/, 1]
-          end
-        end
-        file_list
       end
       
-      def generate_client_file_list
-        r = Chef::REST.new(Chef::Config[:remotefile_url])
-        r.get_rest(generate_url(@new_resource.source, "files", { :recursive => "true" }))
+      # Determine the cookbook to get the file from. If new resource sets an 
+      # explicit cookbook, use it, otherwise fall back to the implicit cookbook
+      # i.e., the cookbook the resource was declared in.
+      def resource_cookbook
+        @new_resource.cookbook || @new_resource.cookbook_name
       end
-      
-      def fetch_remote_file(remote_file_source)
-        full_path = ::File.join(@new_resource.path, remote_file_source)
+
+      def create_cookbook_file(cookbook_file_relative_path)
+        full_path = ::File.join(@new_resource.path, cookbook_file_relative_path)
         
         ensure_directory_exists(::File.dirname(full_path))
         
-        file_to_fetch = provider_for_remote_file(full_path, remote_file_source)
-        file_to_fetch.load_current_resource
-        file_to_fetch.action_create
-        @new_resource.updated = true if file_to_fetch.new_resource.updated        
+        file_to_fetch = cookbook_file_resource(full_path, cookbook_file_relative_path)
+        file_to_fetch.run_action(:create)
+        @new_resource.updated = true if file_to_fetch.updated?
       end
       
-      def provider_for_remote_file(path, source)
-        remote_file = Chef::Resource::RemoteFile.new(path, nil, @node)
-        remote_file.cookbook_name = @new_resource.cookbook || @new_resource.cookbook_name
-        remote_file.source(::File.join(@new_resource.source, source))
-        remote_file.mode(@new_resource.files_mode) if @new_resource.files_mode
-        remote_file.group(@new_resource.files_group) if @new_resource.files_group
-        remote_file.owner(@new_resource.files_owner) if @new_resource.files_owner
-        remote_file.backup(@new_resource.files_backup) if @new_resource.files_backup
+      def cookbook_file_resource(target_path, relative_source_path)
+        cookbook_file = Chef::Resource::CookbookFile.new(target_path, run_context)
+        cookbook_file.cookbook_name = @new_resource.cookbook || @new_resource.cookbook_name
+        cookbook_file.source(::File.join(@new_resource.source, relative_source_path))
+        cookbook_file.mode(@new_resource.files_mode)    if @new_resource.files_mode
+        cookbook_file.group(@new_resource.files_group)  if @new_resource.files_group
+        cookbook_file.owner(@new_resource.files_owner)  if @new_resource.files_owner
+        cookbook_file.backup(@new_resource.files_backup) if @new_resource.files_backup
         
-        Chef::Platform.provider_for_node(@node, remote_file)
+        cookbook_file
       end
       
       def ensure_directory_exists(path)
         unless ::File.directory?(path)
-          directory_to_create = provider_for_directory(path)
-          directory_to_create.load_current_resource
-          directory_to_create.action_create
-          @new_resource.updated = true if directory_to_create.new_resource.updated  
+          directory_to_create = resource_for_directory(path)
+          directory_to_create.run_action(:create)
+          @new_resource.updated = true if directory_to_create.updated?
         end
       end
-      
-      def provider_for_directory(path)
-        new_dir = Chef::Resource::Directory.new(path, nil, @node)
-        new_dir.cookbook_name = @new_resource.cookbook || @new_resource.cookbook_name            
-        new_dir.mode(@new_resource.mode)
-        new_dir.group(@new_resource.group)
-        new_dir.owner(@new_resource.owner)
-        new_dir.recursive(true)
-        
-        Chef::Platform.provider_for_node(@node, new_dir)
-      end
-            
-      def action_create_if_missing
-        raise Chef::Exceptions::UnsupportedAction, "Remote Directories do not support create_if_missing."
+
+      def resource_for_directory(path)
+        dir = Chef::Resource::Directory.new(path, run_context)
+        dir.cookbook_name = @new_resource.cookbook || @new_resource.cookbook_name
+        dir.mode(@new_resource.mode)
+        dir.group(@new_resource.group)
+        dir.owner(@new_resource.owner)
+        dir.recursive(true)
+        dir
       end
 
     end
   end
-end
+end

data/lib/chef/provider/remote_file.rb

@@ -31,56 +31,38 @@ class Chef
 
       def action_create
         Chef::Log.debug("Checking #{@new_resource} for changes")
-        do_remote_file(@new_resource.source, @current_resource.path)
-      end
-
-      def action_create_if_missing
-        if ::File.exists?(@new_resource.path)
-          Chef::Log.debug("File #{@new_resource.path} exists, taking no action.")
-        else
-          action_create
-        end
-      end
-
-      def do_remote_file(source, path)
-        retval = true
 
         if current_resource_matches_target_checksum?
           Chef::Log.debug("File #{@new_resource} checksum matches target checksum (#{@new_resource.checksum}), not updating")
         else
-          begin
-            source_file(source, @current_resource.checksum) do |raw_file|
-              if matches_current_checksum?(raw_file)
-                Chef::Log.debug "#{@new_resource}: Target and Source checksums are the same, taking no action"
-              else
-                backup_new_resource
-                Chef::Log.debug "copying remote file from origin #{raw_file.path} to destination #{@new_resource.path}"
-                FileUtils.cp raw_file.path, @new_resource.path
-                @new_resource.updated = true
-              end
-            end
-          rescue Net::HTTPRetriableError => e
-            if e.response.kind_of?(Net::HTTPNotModified)
-              Chef::Log.debug("File #{path} is unchanged")
-              retval = false
+          Chef::REST.new(@new_resource.source, nil, nil).fetch(@new_resource.source) do |raw_file|
+            if matches_current_checksum?(raw_file)
+              Chef::Log.debug "#{@new_resource}: Target and Source checksums are the same, taking no action"
             else
-              raise e
+              backup_new_resource
+              Chef::Log.debug "copying remote file from origin #{raw_file.path} to destination #{@new_resource.path}"
+              FileUtils.cp raw_file.path, @new_resource.path
+              @new_resource.updated = true
             end
           end
-
-          Chef::Log.debug "#{@new_resource} completed"
-          retval
         end
         enforce_ownership_and_permissions
 
-        retval
+        @new_resource.updated
+      end
+
+      def action_create_if_missing
+        if ::File.exists?(@new_resource.path)
+          Chef::Log.debug("File #{@new_resource.path} exists, taking no action.")
+        else
+          action_create
+        end
       end
 
       def enforce_ownership_and_permissions
         set_owner if @new_resource.owner
         set_group if @new_resource.group
         set_mode  if @new_resource.mode
-
       end
 
       def current_resource_matches_target_checksum?
@@ -94,6 +76,7 @@ class Chef
           @new_resource.checksum(checksum(candidate_file.path))
           Chef::Log.debug "#{@new_resource}: Target checksum: #{@current_resource.checksum}"
           Chef::Log.debug "#{@new_resource}: Source checksum: #{@new_resource.checksum}"
+
           @new_resource.checksum == @current_resource.checksum
         else
           Chef::Log.info "#{@new_resource}: Creating #{@new_resource.path}"
@@ -127,38 +110,6 @@ class Chef
         false
       end
 
-      def fetch_from_uri(source)
-        Chef::Log.debug("Downloading from absolute URI: #{source}")
-        Chef::REST.new(source, nil, nil).fetch(source) { |tmp_file| yield tmp_file  }
-      end
-
-      def fetch_from_chef_server(source, current_checksum)
-        url = generate_url(source, "files", :checksum => current_checksum)
-        Chef::Log.debug("Downloading #{@new_resource} from server: #{url}")
-        Chef::REST.new(Chef::Config[:remotefile_url]).fetch(url) { |tmp_file| yield tmp_file  }
-      end
-
-      def fetch_from_local_cookbook(source)
-        if Chef::Config[:solo]
-          cookbook_name = @new_resource.cookbook || @new_resource.cookbook_name
-          filename = find_preferred_file(
-            cookbook_name,
-            :remote_file,
-            source,
-            @node[:fqdn],
-            @node[:platform],
-            @node[:platform_version]
-          )
-          Chef::Log.debug("Using local file for remote_file:#{filename}")
-          begin
-            file = ::File.open(filename)
-            yield file
-          ensure
-            file.close
-          end
-        end
-      end
-
     end
   end
 end

data/lib/chef/provider/script.rb

@@ -24,19 +24,30 @@ class Chef
     class Script < Chef::Provider::Execute
 
       def action_run
-        tf = Tempfile.new("chef-script")
-        tf.puts(@new_resource.code)
-        tf.close
+        script_file.puts(@new_resource.code)
+        script_file.close
 
-        fr = Chef::Resource::File.new(tf.path, nil, @node)
-        fr.owner(@new_resource.user)
-        fr.group(@new_resource.group)
-        fr.run_action(:create)
+        set_owner_and_group
 
-        @new_resource.command("#{@new_resource.interpreter} #{tf.path}")
+        @new_resource.command("#{@new_resource.interpreter} #{script_file.path}")
         super
       ensure
-        tf && tf.close!
+        unlink_script_file
+      end
+
+      def set_owner_and_group
+        # FileUtils itself implements a no-op if +user+ or +group+ are nil
+        # You can prove this by running FileUtils.chown(nil,nil,'/tmp/file')
+        # as an unprivileged user.
+        FileUtils.chown(@new_resource.user, @new_resource.group, script_file.path)
+      end
+
+      def script_file
+        @script_file ||= Tempfile.open("chef-script")
+      end
+
+      def unlink_script_file
+        @script_file && @script_file.close!
       end
 
     end

data/lib/chef/provider/service.rb

@@ -25,29 +25,27 @@ class Chef
 
       include Chef::Mixin::Command
 
-      def initialize(node, new_resource, collection=nil, definitions=nil, cookbook_loader=nil)
-        super(node, new_resource, collection, definitions, cookbook_loader)
+      def initialize(new_resource, run_context)
+        super
         @enabled = nil
       end
 
       def action_enable
-        unless @current_resource.enabled
+        if @current_resource.enabled
+          Chef::Log.debug("#{@new_resource}: not enabling, already enabled")
+        else
           Chef::Log.debug("#{@new_resource}: attempting to enable")
-          status = enable_service()
-          if status
+          if enable_service
             @new_resource.updated = true
             Chef::Log.info("#{@new_resource}: enabled successfully")
           end
-        else
-          Chef::Log.debug("#{@new_resource}: not enabling, already enabled")
         end
       end
 
       def action_disable
         if @current_resource.enabled
           Chef::Log.debug("#{@new_resource}: attempting to disable")
-          status = disable_service()
-          if status
+          if disable_service
             @new_resource.updated = true
             Chef::Log.info("#{@new_resource}: disabled successfully")
           end
@@ -59,8 +57,7 @@ class Chef
       def action_start
         unless @current_resource.running
           Chef::Log.debug("#{@new_resource}: attempting to start")
-          status = start_service()
-          if status
+          if start_service
             @new_resource.updated = true
             Chef::Log.info("Started service #{@new_resource} successfully")
           end
@@ -72,8 +69,7 @@ class Chef
       def action_stop
         if @current_resource.running
           Chef::Log.debug("#{@new_resource}: attempting to stop")
-          status = stop_service()
-          if status
+          if stop_service
             @new_resource.updated = true
             Chef::Log.info("#{@new_resource}: stopped successfully")
           end
@@ -84,49 +80,46 @@ class Chef
       
       def action_restart
         Chef::Log.debug("#{@new_resource}: attempting to restart")
-        status = restart_service()
-        if status
+        if restart_service
           @new_resource.updated = true
           Chef::Log.info("#{@new_resource}: restarted successfully")
         end
       end
 
       def action_reload
-        unless @new_resource.supports[:reload] or @new_resource.reload_command
+        unless (@new_resource.supports[:reload] || @new_resource.reload_command)
           raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :reload"
-        else
-          if @current_resource.running
-            Chef::Log.debug("#{@new_resource}: attempting to reload")
-            status = reload_service()
-            if status
-              @new_resource.updated = true
-              Chef::Log.info("#{@new_resource}: reloaded successfully")
-            end
+        end
+        if @current_resource.running
+          Chef::Log.debug("#{@new_resource}: attempting to reload")
+          if reload_service
+            @new_resource.updated = true
+            Chef::Log.info("#{@new_resource}: reloaded successfully")
           end
         end
       end
 
-      def enable_service(name)
+      def enable_service
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :enable"
       end
 
-      def disable_service(name)
+      def disable_service
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :disable"
       end
 
-      def start_service(name)
+      def start_service
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :start"
       end
 
-      def stop_service(name)
+      def stop_service
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :stop"
       end 
       
-      def restart_service(name)
+      def restart_service
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :restart"
       end
 
-      def reload_service(name)
+      def reload_service
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :restart"
       end