chef 12.18.31-universal-mingw32 → 12.19.33-universal-mingw32

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

@@ -73,7 +73,7 @@ class Chef
         def restart_service
           ## svcadm restart doesn't supports sync(-s) option
           disable_service
-          return enable_service
+          enable_service
         end
 
         def service_status

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

@@ -89,7 +89,7 @@ class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
       args = "--system"
     end
 
-    return options, args
+    [options, args]
   end
 
   def start_service

data/lib/chef/provider/subversion.rb

@@ -40,11 +40,11 @@ class Chef
       end
 
       def load_current_resource
-        @current_resource = Chef::Resource::Subversion.new(@new_resource.name)
+        @current_resource = Chef::Resource::Subversion.new(new_resource.name)
 
-        unless [:export, :force_export].include?(Array(@new_resource.action).first)
+        unless [:export, :force_export].include?(Array(new_resource.action).first)
           if current_revision = find_current_revision
-            @current_resource.revision current_revision
+            current_resource.revision current_revision
           end
         end
       end
@@ -53,21 +53,21 @@ class Chef
         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)
+          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")
+            "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
         if target_dir_non_existent_or_empty?
-          converge_by("perform checkout of #{@new_resource.repository} into #{@new_resource.destination}") do
+          converge_by("perform checkout of #{new_resource.repository} into #{new_resource.destination}") do
             shell_out!(checkout_command, run_options)
           end
         else
-          Chef::Log.debug "#{@new_resource} checkout destination #{@new_resource.destination} already exists or is a non-empty directory - nothing to do"
+          Chef::Log.debug "#{new_resource} checkout destination #{new_resource.destination} already exists or is a non-empty directory - nothing to do"
         end
       end
 
@@ -75,25 +75,25 @@ class Chef
         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"
+          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
-        converge_by("export #{@new_resource.repository} into #{@new_resource.destination}") do
+        converge_by("export #{new_resource.repository} into #{new_resource.destination}") do
           shell_out!(export_command, run_options)
         end
       end
 
       def action_sync
         assert_target_directory_valid!
-        if ::File.exist?(::File.join(@new_resource.destination, ".svn"))
+        if ::File.exist?(::File.join(new_resource.destination, ".svn"))
           current_rev = find_current_revision
-          Chef::Log.debug "#{@new_resource} current revision: #{current_rev} target revision: #{revision_int}"
+          Chef::Log.debug "#{new_resource} current revision: #{current_rev} target revision: #{revision_int}"
           unless current_revision_matches_target_revision?
-            converge_by("sync #{@new_resource.destination} from #{@new_resource.repository}") do
+            converge_by("sync #{new_resource.destination} from #{new_resource.repository}") do
               shell_out!(sync_command, run_options)
-              Chef::Log.info "#{@new_resource} updated to revision: #{revision_int}"
+              Chef::Log.info "#{new_resource} updated to revision: #{revision_int}"
             end
           end
         else
@@ -102,24 +102,24 @@ class Chef
       end
 
       def sync_command
-        c = scm :update, @new_resource.svn_arguments, verbose, authentication, proxy, "-r#{revision_int}", @new_resource.destination
-        Chef::Log.debug "#{@new_resource} updated working copy #{@new_resource.destination} to revision #{@new_resource.revision}"
+        c = scm :update, new_resource.svn_arguments, verbose, authentication, proxy, "-r#{revision_int}", new_resource.destination
+        Chef::Log.debug "#{new_resource} updated working copy #{new_resource.destination} to revision #{new_resource.revision}"
         c
       end
 
       def checkout_command
-        c = scm :checkout, @new_resource.svn_arguments, verbose, authentication, proxy,
-          "-r#{revision_int}", @new_resource.repository, @new_resource.destination
-        Chef::Log.info "#{@new_resource} checked out #{@new_resource.repository} at revision #{@new_resource.revision} to #{@new_resource.destination}"
+        c = scm :checkout, new_resource.svn_arguments, verbose, authentication, proxy,
+          "-r#{revision_int}", new_resource.repository, new_resource.destination
+        Chef::Log.info "#{new_resource} checked out #{new_resource.repository} at revision #{new_resource.revision} to #{new_resource.destination}"
         c
       end
 
       def export_command
         args = ["--force"]
-        args << @new_resource.svn_arguments << verbose << authentication << proxy <<
-          "-r#{revision_int}" << @new_resource.repository << @new_resource.destination
+        args << new_resource.svn_arguments << verbose << authentication << proxy <<
+          "-r#{revision_int}" << new_resource.repository << new_resource.destination
         c = scm :export, *args
-        Chef::Log.info "#{@new_resource} exported #{@new_resource.repository} at revision #{@new_resource.revision} to #{@new_resource.destination}"
+        Chef::Log.info "#{new_resource} exported #{new_resource.repository} at revision #{new_resource.revision} to #{new_resource.destination}"
         c
       end
 
@@ -128,10 +128,10 @@ class Chef
       # If the specified revision is an integer, trust it.
       def revision_int
         @revision_int ||= begin
-          if @new_resource.revision =~ /^\d+$/
-            @new_resource.revision
+          if new_resource.revision =~ /^\d+$/
+            new_resource.revision
           else
-            command = scm(:info, @new_resource.repository, @new_resource.svn_info_args, authentication, "-r#{@new_resource.revision}")
+            command = scm(:info, new_resource.repository, new_resource.svn_info_args, authentication, "-r#{new_resource.revision}")
             svn_info = shell_out!(command, run_options(:cwd => cwd, :returns => [0, 1])).stdout
 
             extract_revision_info(svn_info)
@@ -142,7 +142,7 @@ class Chef
       alias :revision_slug :revision_int
 
       def find_current_revision
-        return nil unless ::File.exist?(::File.join(@new_resource.destination, ".svn"))
+        return nil unless ::File.exist?(::File.join(new_resource.destination, ".svn"))
         command = scm(:info)
         svn_info = shell_out!(command, run_options(:cwd => cwd, :returns => [0, 1])).stdout
 
@@ -150,20 +150,20 @@ class Chef
       end
 
       def current_revision_matches_target_revision?
-        (!@current_resource.revision.nil?) && (revision_int.strip.to_i == @current_resource.revision.strip.to_i)
+        (!current_resource.revision.nil?) && (revision_int.strip.to_i == current_resource.revision.strip.to_i)
       end
 
       def run_options(run_opts = {})
-        run_opts[:user] = @new_resource.user if @new_resource.user
-        run_opts[:group] = @new_resource.group if @new_resource.group
-        run_opts[:timeout] = @new_resource.timeout if @new_resource.timeout
+        run_opts[:user] = new_resource.user if new_resource.user
+        run_opts[:group] = new_resource.group if new_resource.group
+        run_opts[:timeout] = new_resource.timeout if new_resource.timeout
         run_opts
       end
 
       private
 
       def cwd
-        @new_resource.destination
+        new_resource.destination
       end
 
       def verbose
@@ -181,7 +181,7 @@ class Chef
         rev = (repo_attrs["Last Changed Rev"] || repo_attrs["Revision"])
         rev.strip! if rev
         raise "Could not parse `svn info` data: #{svn_info}" if repo_attrs.empty?
-        Chef::Log.debug "#{@new_resource} resolved revision #{@new_resource.revision} to #{rev}"
+        Chef::Log.debug "#{new_resource} resolved revision #{new_resource.revision} to #{rev}"
         rev
       end
 
@@ -190,14 +190,14 @@ class Chef
       # switch, since Capistrano will check for that prompt in the output
       # and will respond appropriately.
       def authentication
-        return "" unless @new_resource.svn_username
-        result = "--username #{@new_resource.svn_username} "
-        result << "--password #{@new_resource.svn_password} "
+        return "" unless new_resource.svn_username
+        result = "--username #{new_resource.svn_username} "
+        result << "--password #{new_resource.svn_password} "
         result
       end
 
       def proxy
-        repo_uri = URI.parse(@new_resource.repository)
+        repo_uri = URI.parse(new_resource.repository)
         proxy_uri = Chef::Config.proxy_uri(repo_uri.scheme, repo_uri.host, repo_uri.port)
         return "" if proxy_uri.nil?
 
@@ -213,18 +213,18 @@ class Chef
       end
 
       def target_dir_non_existent_or_empty?
-        !::File.exist?(@new_resource.destination) || Dir.entries(@new_resource.destination).sort == [".", ".."]
+        !::File.exist?(new_resource.destination) || Dir.entries(new_resource.destination).sort == [".", ".."]
       end
 
       def svn_binary
-        @new_resource.svn_binary ||
+        new_resource.svn_binary ||
           (Chef::Platform.windows? ? "svn.exe" : "svn")
       end
 
       def assert_target_directory_valid!
-        target_parent_directory = ::File.dirname(@new_resource.destination)
+        target_parent_directory = ::File.dirname(new_resource.destination)
         unless ::File.directory?(target_parent_directory)
-          msg = "Cannot clone #{@new_resource} to #{@new_resource.destination}, the enclosing directory #{target_parent_directory} does not exist"
+          msg = "Cannot clone #{new_resource} to #{new_resource.destination}, the enclosing directory #{target_parent_directory} does not exist"
           raise Chef::Exceptions::MissingParentDirectory, msg
         end
       end

data/lib/chef/provider/systemd_unit.rb

@@ -20,6 +20,7 @@ require "chef/provider"
 require "chef/mixin/which"
 require "chef/mixin/shell_out"
 require "chef/resource/file"
+require "chef/resource/file/verification/systemd_unit"
 require "iniparse"
 
 class Chef
@@ -193,6 +194,7 @@ class Chef
           f.group "root"
           f.mode "0644"
           f.content new_resource.to_ini
+          f.verify :systemd_unit
         end.run_action(action)
       end
 

data/lib/chef/provider/template.rb

@@ -37,7 +37,7 @@ class Chef
       end
 
       def load_current_resource
-        @current_resource = Chef::Resource::Template.new(@new_resource.name)
+        @current_resource = Chef::Resource::Template.new(new_resource.name)
         super
       end
 
@@ -55,8 +55,8 @@ class Chef
       private
 
       def managing_content?
-        return true if @new_resource.checksum
-        return true if !@new_resource.source.nil? && @action != :create_if_missing
+        return true if new_resource.checksum
+        return true if !new_resource.source.nil? && @action != :create_if_missing
         false
       end
 

data/lib/chef/provider/user.rb

@@ -36,8 +36,8 @@ class Chef
       end
 
       def convert_group_name
-        if @new_resource.gid.is_a? String
-          @new_resource.gid(Etc.getgrnam(@new_resource.gid).gid)
+        if new_resource.gid.is_a? String
+          new_resource.gid(Etc.getgrnam(new_resource.gid).gid)
         end
       rescue ArgumentError
         @group_name_resolved = false
@@ -48,51 +48,51 @@ class Chef
       end
 
       def load_current_resource
-        @current_resource = Chef::Resource::User.new(@new_resource.name)
-        @current_resource.username(@new_resource.username)
+        @current_resource = Chef::Resource::User.new(new_resource.name)
+        current_resource.username(new_resource.username)
 
         begin
-          user_info = Etc.getpwnam(@new_resource.username)
+          user_info = Etc.getpwnam(new_resource.username)
         rescue ArgumentError
           @user_exists = false
-          Chef::Log.debug("#{@new_resource} user does not exist")
+          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)
-          @current_resource.home(user_info.dir)
-          @current_resource.shell(user_info.shell)
-          @current_resource.password(user_info.passwd)
-
-          if @new_resource.comment
-            user_info.gecos.force_encoding(@new_resource.comment.encoding)
+          current_resource.uid(user_info.uid)
+          current_resource.gid(user_info.gid)
+          current_resource.home(user_info.dir)
+          current_resource.shell(user_info.shell)
+          current_resource.password(user_info.passwd)
+
+          if new_resource.comment
+            user_info.gecos.force_encoding(new_resource.comment.encoding)
           end
-          @current_resource.comment(user_info.gecos)
+          current_resource.comment(user_info.gecos)
 
-          if @new_resource.password && @current_resource.password == "x"
+          if new_resource.password && current_resource.password == "x"
             begin
               require "shadow"
             rescue LoadError
               @shadow_lib_ok = false
             else
-              shadow_info = Shadow::Passwd.getspnam(@new_resource.username)
-              @current_resource.password(shadow_info.sp_pwdp)
+              shadow_info = Shadow::Passwd.getspnam(new_resource.username)
+              current_resource.password(shadow_info.sp_pwdp)
             end
           end
 
-          convert_group_name if @new_resource.gid
+          convert_group_name if new_resource.gid
         end
 
-        @current_resource
+        current_resource
       end
 
       def define_resource_requirements
         requirements.assert(:create, :modify, :manage, :lock, :unlock) 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."
+          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 }
@@ -102,8 +102,8 @@ class Chef
         end
         requirements.assert(:modify, :lock, :unlock) do |a|
           a.assertion { @user_exists }
-          a.failure_message(Chef::Exceptions::User, "Cannot modify user #{@new_resource.username} - does not exist!")
-          a.whyrun("Assuming user #{@new_resource.username} would have been created")
+          a.failure_message(Chef::Exceptions::User, "Cannot modify user #{new_resource.username} - does not exist!")
+          a.whyrun("Assuming user #{new_resource.username} would have been created")
         end
       end
 
@@ -113,10 +113,10 @@ class Chef
       # <true>:: If a change is required
       # <false>:: If the users are identical
       def compare_user
-        return true if !@new_resource.home.nil? && Pathname.new(@new_resource.home).cleanpath != Pathname.new(@current_resource.home).cleanpath
+        return true if !new_resource.home.nil? && Pathname.new(new_resource.home).cleanpath != Pathname.new(current_resource.home).cleanpath
 
         [ :comment, :shell, :password, :uid, :gid ].each do |user_attrib|
-          return true if !@new_resource.send(user_attrib).nil? && @new_resource.send(user_attrib).to_s != @current_resource.send(user_attrib).to_s
+          return true if !new_resource.send(user_attrib).nil? && new_resource.send(user_attrib).to_s != current_resource.send(user_attrib).to_s
         end
 
         false
@@ -124,61 +124,61 @@ class Chef
 
       def action_create
         if !@user_exists
-          converge_by("create user #{@new_resource.username}") do
+          converge_by("create user #{new_resource.username}") do
             create_user
-            Chef::Log.info("#{@new_resource} created")
+            Chef::Log.info("#{new_resource} created")
           end
         elsif compare_user
-          converge_by("alter user #{@new_resource.username}") do
+          converge_by("alter user #{new_resource.username}") do
             manage_user
-            Chef::Log.info("#{@new_resource} altered")
+            Chef::Log.info("#{new_resource} altered")
           end
         end
       end
 
       def action_remove
         return unless @user_exists
-        converge_by("remove user #{@new_resource.username}") do
+        converge_by("remove user #{new_resource.username}") do
           remove_user
-          Chef::Log.info("#{@new_resource} removed")
+          Chef::Log.info("#{new_resource} removed")
         end
       end
 
       def action_manage
         return unless @user_exists && compare_user
-        converge_by("manage user #{@new_resource.username}") do
+        converge_by("manage user #{new_resource.username}") do
           manage_user
-          Chef::Log.info("#{@new_resource} managed")
+          Chef::Log.info("#{new_resource} managed")
         end
       end
 
       def action_modify
         return unless compare_user
-        converge_by("modify user #{@new_resource.username}") do
+        converge_by("modify user #{new_resource.username}") do
           manage_user
-          Chef::Log.info("#{@new_resource} modified")
+          Chef::Log.info("#{new_resource} modified")
         end
       end
 
       def action_lock
         if check_lock == false
-          converge_by("lock the user #{@new_resource.username}") do
+          converge_by("lock the user #{new_resource.username}") do
             lock_user
-            Chef::Log.info("#{@new_resource} locked")
+            Chef::Log.info("#{new_resource} locked")
           end
         else
-          Chef::Log.debug("#{@new_resource} already locked - nothing to do")
+          Chef::Log.debug("#{new_resource} already locked - nothing to do")
         end
       end
 
       def action_unlock
         if check_lock == true
-          converge_by("unlock user #{@new_resource.username}") do
+          converge_by("unlock user #{new_resource.username}") do
             unlock_user
-            Chef::Log.info("#{@new_resource} unlocked")
+            Chef::Log.info("#{new_resource} unlocked")
           end
         else
-          Chef::Log.debug("#{@new_resource} already unlocked - nothing to do")
+          Chef::Log.debug("#{new_resource} already unlocked - nothing to do")
         end
       end
 

data/lib/chef/provider/whyrun_safe_ruby_block.rb

@@ -22,10 +22,10 @@ class Chef
       provides :whyrun_safe_ruby_block
 
       def action_run
-        @new_resource.block.call
-        @new_resource.updated_by_last_action(true)
-        @run_context.events.resource_update_applied(@new_resource, :create, "execute the whyrun_safe_ruby_block #{@new_resource.name}")
-        Chef::Log.info("#{@new_resource} called")
+        new_resource.block.call
+        new_resource.updated_by_last_action(true)
+        @run_context.events.resource_update_applied(new_resource, :create, "execute the whyrun_safe_ruby_block #{new_resource.name}")
+        Chef::Log.info("#{new_resource} called")
       end
     end
   end