chef 10.12.0 → 10.14.0.beta.1

data/lib/chef/provider/service/solaris.rb

@@ -29,6 +29,10 @@ class Chef
           @init_command = "/usr/sbin/svcadm"
           @status_command = "/bin/svcs -l"
         end
+        
+        def whyrun_supported?
+          false
+        end
 
         def load_current_resource
           @current_resource = Chef::Resource::Service.new(@new_resource.name)

data/lib/chef/provider/service/systemd.rb

@@ -24,6 +24,7 @@ class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
   def load_current_resource
     @current_resource = Chef::Resource::Service.new(@new_resource.name)
     @current_resource.service_name(@new_resource.service_name)
+    @status_check_success = true
 
     if @new_resource.status_command
       Chef::Log.debug("#{@new_resource} you have specified a status command, running..")
@@ -33,7 +34,9 @@ class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
           @current_resource.running(true)
         end
       rescue Chef::Exceptions::Exec
+        @status_check_success = false
         @current_resource.running(false)
+        @current_resource.enabled(false)
         nil
       end
     else
@@ -44,6 +47,16 @@ class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
     @current_resource
   end
 
+  def define_resource_requirements
+    super
+    requirements.assert(:all_actions) do |a|
+      a.assertion { @status_check_success } 
+      # We won't stop in any case, but in whyrun warn and tell what we're doing.
+      a.whyrun ["Failed to determine status of #{@new_resource}, using command #{@new_resource.status_command}.",
+        "Assuming service would have been installed and is disabled"]
+    end
+  end
+
   def start_service
     if @current_resource.running
       Chef::Log.debug("#{@new_resource} already running, not starting")

data/lib/chef/provider/service/upstart.rb

@@ -59,6 +59,30 @@ class Chef
             @upstart_job_dir = "/etc/init"
             @upstart_conf_suffix = ".conf"
           end
+
+          @command_success = true # new_resource.status_command= false, means upstart used 
+          @config_file_found = true 
+          @upstart_command_success = true
+        end
+
+        def define_resource_requirements 
+          super
+
+          requirements.assert(:all_actions) do |a| 
+            if !@command_success
+              whyrun_msg = @new_resource.status_command ? "Provided status command #{@new_resource.status_command} failed." : 
+                "Could not determine upstart state for service"
+            end
+            a.assertion { @command_success }
+            # no failure here, just document the assumptions made. 
+            a.whyrun "#{whyrun_msg} Assuming service installed and not running." 
+          end
+
+          requirements.assert(:all_actions) do |a| 
+            a.assertion  { @config_file_found } 
+            # no failure here, just document the assumptions made. 
+            a.whyrun "Could not find #{@upstart_job_dir}/#{@new_resource.service_name}#{@upstart_conf_suffix}. Assuming service is disabled." 
+          end
         end
 
         def load_current_resource
@@ -76,6 +100,7 @@ class Chef
                 @current_resource.running true
               end
             rescue Chef::Exceptions::Exec
+              @command_success = false
               @current_resource.running false
               nil
             end
@@ -87,11 +112,11 @@ class Chef
                 @current_resource.running false
               end
             rescue Chef::Exceptions::Exec
+              @command_success = false
               @current_resource.running false
               nil
             end
           end
-
           # Get enabled/disabled state by reading job configuration file
           if ::File.exists?("#{@upstart_job_dir}/#{@new_resource.service_name}#{@upstart_conf_suffix}")
             Chef::Log.debug("#{@new_resource} found #{@upstart_job_dir}/#{@new_resource.service_name}#{@upstart_conf_suffix}")
@@ -110,6 +135,7 @@ class Chef
               end
             end
           else
+            @config_file_found = false
             Chef::Log.debug("#{@new_resource} did not find #{@upstart_job_dir}/#{@new_resource.service_name}#{@upstart_conf_suffix}")
             @current_resource.enabled false
           end

data/lib/chef/provider/service/windows.rb

@@ -33,6 +33,10 @@ class Chef::Provider::Service::Windows < Chef::Provider::Service
   AUTO_START = 'auto start'
   DISABLED = 'disabled'
 
+  def whyrun_supported?
+    false
+  end
+
   def load_current_resource
     @current_resource = Chef::Resource::Service.new(@new_resource.name)
     @current_resource.service_name(@new_resource.service_name)

data/lib/chef/provider/subversion.rb

@@ -17,6 +17,8 @@
 #
 
 
+#TODO subversion and git should both extend from a base SCM provider. 
+
 require 'chef/log'
 require 'chef/provider'
 require 'chef/mixin/command'
@@ -30,6 +32,10 @@ class Chef
 
       include Chef::Mixin::Command
 
+      def whyrun_supported?
+        true
+      end
+
       def load_current_resource
         @current_resource = Chef::Resource::Subversion.new(@new_resource.name)
 
@@ -40,30 +46,40 @@ class Chef
         end
       end
 
+      def define_resource_requirements
+        requirements.assert(:all_actions)  do |a|
+          # Make sure the parent dir exists, or else fail.
+          # for why run, print a message explaining the potential error.
+          parent_directory = ::File.dirname(@new_resource.destination)
+          a.assertion { ::File.directory?(parent_directory) }
+          a.failure_message(Chef::Exceptions::MissingParentDirectory, 
+            "Cannot clone #{@new_resource} to #{@new_resource.destination}, the enclosing directory #{parent_directory} does not exist")
+          a.whyrun("Directory #{parent_directory} does not exist, assuming it would have been created")
+        end
+      end
+
       def action_checkout
-        assert_target_directory_valid!
-        if target_dir_non_existant_or_empty?
-          run_command(run_options(:command => checkout_command))
-          @new_resource.updated_by_last_action(true)
+        if target_dir_non_existent_or_empty?
+          converge_by("perform checkout of #{@new_resource.repository} into #{@new_resource.destination}") do
+            run_command(run_options(:command => checkout_command))
+          end
         else
           Chef::Log.debug "#{@new_resource} checkout destination #{@new_resource.destination} already exists or is a non-empty directory - nothing to do"
         end
       end
 
       def action_export
-        assert_target_directory_valid!
-        if target_dir_non_existant_or_empty?
-          run_command(run_options(:command => export_command))
-          @new_resource.updated_by_last_action(true)
+        if target_dir_non_existent_or_empty?
+          action_force_export
         else
           Chef::Log.debug "#{@new_resource} export destination #{@new_resource.destination} already exists or is a non-empty directory - nothing to do"
         end
       end
 
       def action_force_export
-        assert_target_directory_valid!
-        run_command(run_options(:command => export_command))
-        @new_resource.updated_by_last_action(true)
+        converge_by("export #{@new_resource.repository} into #{@new_resource.destination}") do
+          run_command(run_options(:command => export_command))
+        end
       end
 
       def action_sync
@@ -72,16 +88,16 @@ class Chef
           current_rev = find_current_revision
           Chef::Log.debug "#{@new_resource} current revision: #{current_rev} target revision: #{revision_int}"
           unless current_revision_matches_target_revision?
-            run_command(run_options(:command => sync_command))
-            Chef::Log.info "#{@new_resource} updated to revision: #{revision_int}"
-            @new_resource.updated_by_last_action(true)
+            converge_by("sync #{@new_resource.destination} from #{@new_resource.repository}") do
+              run_command(run_options(:command => sync_command))
+              Chef::Log.info "#{@new_resource} updated to revision: #{revision_int}"
+            end 
           end
         else
           action_checkout
-          @new_resource.updated_by_last_action(true)
         end
       end
-
+      
       def sync_command
         c = scm :update, @new_resource.svn_arguments, verbose, authentication, "-r#{revision_int}", @new_resource.destination
         Chef::Log.debug "#{@new_resource} updated working copy #{@new_resource.destination} to revision #{@new_resource.revision}"
@@ -182,8 +198,10 @@ class Chef
         ['svn', *args].compact.join(" ")
       end
       
-      # TODO these methods are the same as the git provider...need to REFACTOR
-      # ...the subversion and git providers should extend from the same parent
+
+      def target_dir_non_existent_or_empty?
+        !::File.exist?(@new_resource.destination) || Dir.entries(@new_resource.destination).sort == ['.','..']
+      end
       def assert_target_directory_valid!
         target_parent_directory = ::File.dirname(@new_resource.destination)
         unless ::File.directory?(target_parent_directory)
@@ -191,10 +209,6 @@ class Chef
           raise Chef::Exceptions::MissingParentDirectory, msg
         end
       end
-
-      def target_dir_non_existant_or_empty?
-        !::File.exist?(@new_resource.destination) || Dir.entries(@new_resource.destination).sort == ['.','..']
-      end
     end
   end
 end

data/lib/chef/provider/template.rb

@@ -34,30 +34,41 @@ class Chef
         super
         @current_resource.checksum(checksum(@current_resource.path)) if ::File.exist?(@current_resource.path)
       end
+      
+      def define_resource_requirements
+        super
+
+        requirements.assert(:create, :create_if_missing) do |a| 
+          a.assertion { ::File::exist?(template_location) } 
+          a.failure_message "Template source #{template_location} could not be found."
+          a.whyrun "Template source #{template_location} does not exist. Assuming it would have been created."
+          a.block_action!
+        end
+      end
 
       def action_create
         render_with_context(template_location) do |rendered_template|
           rendered(rendered_template)
-          if ::File.exist?(@new_resource.path) && content_matches?
+          update = ::File.exist?(@new_resource.path)
+          if update && content_matches?
             Chef::Log.debug("#{@new_resource} content has not changed.")
-            set_all_access_controls(@new_resource.path)
+            set_all_access_controls
           else
-            backup
-            set_all_access_controls(rendered_template.path)
-            FileUtils.mv(rendered_template.path, @new_resource.path)
-            Chef::Log.info("#{@new_resource} updated content")
-            @new_resource.updated_by_last_action(true)
+            description = [] 
+            action_message = update ? "update #{@current_resource} from #{short_cksum(@current_resource.checksum)} to #{short_cksum(@new_resource.checksum)}" :
+              "create #{@new_resource}"
+            description << action_message
+            description << diff_current(rendered_template.path)
+            converge_by(description) do
+              backup
+              FileUtils.mv(rendered_template.path, @new_resource.path)
+              Chef::Log.info("#{@new_resource} updated content")
+              access_controls.set_all!
+            end
           end
-        end
+        end  
       end
 
-      def action_create_if_missing
-        if ::File.exists?(@new_resource.path)
-          Chef::Log.debug("#{@new_resource} exists - taking no action")
-        else
-          action_create
-        end
-      end
 
       def template_location
         @template_file_cache_location ||= begin
@@ -69,7 +80,7 @@ class Chef
           end
         end
       end
-      
+
       def resource_cookbook
         @new_resource.cookbook || @new_resource.cookbook_name
       end
@@ -84,12 +95,6 @@ class Chef
         @current_resource.checksum == @new_resource.checksum
       end
 
-      def set_all_access_controls(file)
-        access_controls = Chef::FileAccessControl.new(@new_resource, file)
-        access_controls.set_all
-        @new_resource.updated_by_last_action(access_controls.modified?)
-      end
-
       private
 
       def render_with_context(template_location, &block)

data/lib/chef/provider/user.rb

@@ -24,29 +24,35 @@ require 'etc'
 class Chef
   class Provider
     class User < Chef::Provider
-      
+
       include Chef::Mixin::Command
-      
+
       attr_accessor :user_exists, :locked
-      
+
       def initialize(new_resource, run_context)
         super
         @user_exists = true
         @locked = nil
+        @shadow_lib_ok = true
+        @group_name_resolved = true
       end
-  
+
       def convert_group_name
         if @new_resource.gid.is_a? String
           @new_resource.gid(Etc.getgrnam(@new_resource.gid).gid)
         end
       rescue ArgumentError => e
-        raise Chef::Exceptions::User, "Couldn't lookup integer GID for group name #{@new_resource.gid}"
+        @group_name_resolved = false
       end
-      
+
+      def whyrun_supported?
+        true
+      end
+
       def load_current_resource
         @current_resource = Chef::Resource::User.new(@new_resource.name)
         @current_resource.username(@new_resource.username)
-      
+
         begin
           user_info = Etc.getpwnam(@new_resource.username)
         rescue ArgumentError => e
@@ -54,7 +60,7 @@ class Chef
           Chef::Log.debug("#{@new_resource} user does not exist")
           user_info = nil
         end
-        
+
         if user_info
           @current_resource.uid(user_info.uid)
           @current_resource.gid(user_info.gid)
@@ -62,26 +68,45 @@ class Chef
           @current_resource.home(user_info.dir)
           @current_resource.shell(user_info.shell)
           @current_resource.password(user_info.passwd)
-        
+
           if @new_resource.password && @current_resource.password == 'x'
             begin
               require 'shadow'
             rescue LoadError
-              raise Chef::Exceptions::MissingLibrary, "You must have ruby-shadow installed for password support!"
+              @shadow_lib_ok = false
             else
               shadow_info = Shadow::Passwd.getspnam(@new_resource.username)
               @current_resource.password(shadow_info.sp_pwdp)
             end
           end
-          
+
           if @new_resource.gid
             convert_group_name
           end
         end
-        
+
         @current_resource
       end
 
+      def define_resource_requirements
+        requirements.assert(:all_actions) do |a|
+          a.assertion { @group_name_resolved } 
+          a.failure_message Chef::Exceptions::User, "Couldn't lookup integer GID for group name #{@new_resource.gid}"
+          a.whyrun "group name #{@new_resource.gid} does not exist.  This will cause group assignment to fail.  Assuming this group will have been created previously."
+        end
+        requirements.assert(:all_actions) do |a|
+          a.assertion { @shadow_lib_ok } 
+          a.failure_message Chef::Exceptions::MissingLibrary, "You must have ruby-shadow installed for password support!"
+          a.whyrun "ruby-shadow is not installed. Attempts to set user password will cause failure.  Assuming that this gem will have been previously installed." + 
+                   "Note that user update converge may report false-positive on the basis of mismatched password. "
+        end
+        requirements.assert(:modify, :lock, :unlock) do |a|
+          a.assertion { @user_exists }
+          a.failure_message(Chef::Exceptions::User, "Cannot modify user #{@new_resource} - does not exist!")
+          a.whyrun("Assuming user #{@new_resource} would have been created")
+        end
+      end
+
       # Check to see if the user needs any changes
       #
       # === Returns
@@ -92,24 +117,28 @@ class Chef
           !@new_resource.send(user_attrib).nil? && @new_resource.send(user_attrib) != @current_resource.send(user_attrib)
         end
       end
-      
+
       def action_create
+
         if !@user_exists
-          create_user
-          Chef::Log.info("#{@new_resource} created")
-          @new_resource.updated_by_last_action(true)
+          converge_by("create user #{@new_resource}") do
+            create_user
+            Chef::Log.info("#{@new_resource} created")
+          end
         elsif compare_user
-          manage_user
-          Chef::Log.info("#{@new_resource} altered")
-          @new_resource.updated_by_last_action(true)
+          converge_by("alter user #{@new_resource}") do
+            manage_user
+            Chef::Log.info("#{@new_resource} altered")
+          end
         end
       end
-      
+
       def action_remove
         if @user_exists
-          remove_user
-          @new_resource.updated_by_last_action(true)
-          Chef::Log.info("#{@new_resource} removed")
+          converge_by("remove user #{@new_resource}") do
+            remove_user
+            Chef::Log.info("#{@new_resource} removed")
+          end
         end
       end
 
@@ -119,9 +148,10 @@ class Chef
 
       def action_manage
         if @user_exists && compare_user
-          manage_user
-          @new_resource.updated_by_last_action(true)
-          Chef::Log.info("#{@new_resource} managed")
+          converge_by("manage user #{@new_resource}") do
+            manage_user
+            Chef::Log.info("#{@new_resource} managed")
+          end
         end
       end
 
@@ -130,28 +160,22 @@ class Chef
       end
 
       def action_modify
-        if @user_exists
-          if compare_user
+        if compare_user
+          converge_by("modify user #{@new_resource}") do
             manage_user
-            @new_resource.updated_by_last_action(true)
             Chef::Log.info("#{@new_resource} modified")
           end
-        else
-          raise Chef::Exceptions::User, "Cannot modify user - does not exist!"
         end
       end
 
       def action_lock
-        if @user_exists
-          if check_lock() == false
+        if check_lock() == false
+          converge_by("lock the user #{@new_resource}") do
             lock_user
-            @new_resource.updated_by_last_action(true)
             Chef::Log.info("#{@new_resource} locked")
-          else
-            Chef::Log.debug("#{@new_resource} already locked - nothing to do")
           end
-        else
-          raise Chef::Exceptions::User, "Cannot lock user - does not exist!"
+         else
+          Chef::Log.debug("#{@new_resource} already locked - nothing to do")
         end
       end
 
@@ -164,19 +188,16 @@ class Chef
       end
 
       def action_unlock
-        if @user_exists
-          if check_lock() == true
+        if check_lock() == true
+          converge_by("unlock user #{@new_resource}") do
             unlock_user
-            @new_resource.updated_by_last_action(true)
             Chef::Log.info("#{@new_resource} unlocked")
-          else
-            Chef::Log.debug("#{@new_resource} already unlocked - nothing to do")
           end
         else
-          raise Chef::Exceptions::User, "Cannot unlock user - does not exist!"
+          Chef::Log.debug("#{@new_resource} already unlocked - nothing to do")
         end
       end
-      
+
       def unlock_user
         raise NotImplementedError
       end