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

data/lib/chef/provider/deploy/revision.rb

@@ -91,11 +91,9 @@ class Chef
         end
 
         def load_cache
-          begin
-            Chef::JSONCompat.parse(Chef::FileCache.load("revision-deploys/#{new_resource.name}"))
-          rescue Chef::Exceptions::FileNotFound
-            sorted_releases_from_filesystem
-          end
+          Chef::JSONCompat.parse(Chef::FileCache.load("revision-deploys/#{new_resource.name}"))
+        rescue Chef::Exceptions::FileNotFound
+          sorted_releases_from_filesystem
         end
 
         def save_cache(cache)

data/lib/chef/provider/directory.rb

@@ -34,12 +34,12 @@ class Chef
       end
 
       def load_current_resource
-        @current_resource = Chef::Resource::Directory.new(@new_resource.name)
-        @current_resource.path(@new_resource.path)
-        if ::File.exists?(@current_resource.path) && @action != :create_if_missing
-          load_resource_attributes_from_file(@current_resource)
+        @current_resource = Chef::Resource::Directory.new(new_resource.name)
+        current_resource.path(new_resource.path)
+        if ::File.exists?(current_resource.path) && @action != :create_if_missing
+          load_resource_attributes_from_file(current_resource)
         end
-        @current_resource
+        current_resource
       end
 
       def define_resource_requirements
@@ -49,9 +49,9 @@ class Chef
         requirements.assert(:create) 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.path)
+          parent_directory = ::File.dirname(new_resource.path)
           a.assertion do
-            if @new_resource.recursive
+            if new_resource.recursive
               does_parent_exist = lambda do |base_dir|
                 base_dir = ::File.dirname(base_dir)
                 if ::File.exist?(base_dir)
@@ -60,20 +60,20 @@ class Chef
                   does_parent_exist.call(base_dir)
                 end
               end
-              does_parent_exist.call(@new_resource.path)
+              does_parent_exist.call(new_resource.path)
             else
               ::File.directory?(parent_directory)
             end
           end
-          a.failure_message(Chef::Exceptions::EnclosingDirectoryDoesNotExist, "Parent directory #{parent_directory} does not exist, cannot create #{@new_resource.path}")
+          a.failure_message(Chef::Exceptions::EnclosingDirectoryDoesNotExist, "Parent directory #{parent_directory} does not exist, cannot create #{new_resource.path}")
           a.whyrun("Assuming directory #{parent_directory} would have been created")
         end
 
         requirements.assert(:create) do |a|
-          parent_directory = ::File.dirname(@new_resource.path)
+          parent_directory = ::File.dirname(new_resource.path)
           a.assertion do
-            if @new_resource.recursive
-              # find the lowest-level directory in @new_resource.path that already exists
+            if new_resource.recursive
+              # find the lowest-level directory in new_resource.path that already exists
               # make sure we have write permissions to that directory
               is_parent_writable = lambda do |base_dir|
                 base_dir = ::File.dirname(base_dir)
@@ -89,7 +89,7 @@ class Chef
                   is_parent_writable.call(base_dir)
                 end
               end
-              is_parent_writable.call(@new_resource.path)
+              is_parent_writable.call(new_resource.path)
             else
               # in why run mode & parent directory does not exist no permissions check is required
               # If not in why run, permissions must be valid and we rely on prior assertion that dir exists
@@ -97,7 +97,7 @@ class Chef
                 if Chef::FileAccessControl.writable?(parent_directory)
                   true
                 elsif Chef::Util::PathHelper.is_sip_path?(parent_directory, node)
-                  Chef::Util::PathHelper.writable_sip_path?(@new_resource.path)
+                  Chef::Util::PathHelper.writable_sip_path?(new_resource.path)
                 else
                   false
                 end
@@ -107,18 +107,18 @@ class Chef
             end
           end
           a.failure_message(Chef::Exceptions::InsufficientPermissions,
-            "Cannot create #{@new_resource} at #{@new_resource.path} due to insufficient permissions")
+            "Cannot create #{new_resource} at #{new_resource.path} due to insufficient permissions")
         end
 
         requirements.assert(:delete) do |a|
           a.assertion do
-            if ::File.exists?(@new_resource.path)
-              ::File.directory?(@new_resource.path) && Chef::FileAccessControl.writable?(@new_resource.path)
+            if ::File.exists?(new_resource.path)
+              ::File.directory?(new_resource.path) && Chef::FileAccessControl.writable?(new_resource.path)
             else
               true
             end
           end
-          a.failure_message(RuntimeError, "Cannot delete #{@new_resource} at #{@new_resource.path}!")
+          a.failure_message(RuntimeError, "Cannot delete #{new_resource} at #{new_resource.path}!")
           # No why-run handling here:
           #  * if we don't have permissions, this is unlikely to be changed earlier in the run
           #  * if the target is a file (not a dir), there's no reasonable path by which this would have been changed
@@ -126,32 +126,32 @@ class Chef
       end
 
       def action_create
-        unless ::File.exists?(@new_resource.path)
-          converge_by("create new directory #{@new_resource.path}") do
-            if @new_resource.recursive == true
-              ::FileUtils.mkdir_p(@new_resource.path)
+        unless ::File.exists?(new_resource.path)
+          converge_by("create new directory #{new_resource.path}") do
+            if new_resource.recursive == true
+              ::FileUtils.mkdir_p(new_resource.path)
             else
-              ::Dir.mkdir(@new_resource.path)
+              ::Dir.mkdir(new_resource.path)
             end
-            Chef::Log.info("#{@new_resource} created directory #{@new_resource.path}")
+            Chef::Log.info("#{new_resource} created directory #{new_resource.path}")
           end
         end
         do_acl_changes
         do_selinux(true)
-        load_resource_attributes_from_file(@new_resource)
+        load_resource_attributes_from_file(new_resource) unless Chef::Config[:why_run]
       end
 
       def action_delete
-        if ::File.exists?(@new_resource.path)
-          converge_by("delete existing directory #{@new_resource.path}") do
-            if @new_resource.recursive == true
+        if ::File.exists?(new_resource.path)
+          converge_by("delete existing directory #{new_resource.path}") do
+            if new_resource.recursive == true
               # we don't use rm_rf here because it masks all errors, including
               # IO errors or permission errors that would prvent the deletion
-              FileUtils.rm_r(@new_resource.path)
-              Chef::Log.info("#{@new_resource} deleted #{@new_resource.path} recursively")
+              FileUtils.rm_r(new_resource.path)
+              Chef::Log.info("#{new_resource} deleted #{new_resource.path} recursively")
             else
-              ::Dir.delete(@new_resource.path)
-              Chef::Log.info("#{@new_resource} deleted #{@new_resource.path}")
+              ::Dir.delete(new_resource.path)
+              Chef::Log.info("#{new_resource} deleted #{new_resource.path}")
             end
           end
         end

data/lib/chef/provider/dsc_resource.rb

@@ -29,6 +29,7 @@ class Chef
         super
         @new_resource = new_resource
         @module_name = new_resource.module_name
+        @module_version = new_resource.module_version
         @reboot_resource = nil
       end
 
@@ -65,6 +66,13 @@ class Chef
           a.whyrun err + ["Assuming a previous resource sets the RefreshMode."]
           a.block_action!
         end
+        requirements.assert(:run) do |a|
+          a.assertion { module_usage_valid? }
+          err = ["module_name must be supplied along with module_version."]
+          a.failure_message Chef::Exceptions::DSCModuleNameMissing,
+            err
+          a.block_action!
+        end
       end
 
       protected
@@ -92,6 +100,10 @@ class Chef
         Chef::Platform.supports_refresh_mode_enabled?(node)
       end
 
+      def module_usage_valid?
+        !(!@module_name && @module_version)
+      end
+
       def generate_description
         @converge_description
       end
@@ -148,10 +160,14 @@ class Chef
         end
       end
 
+      def module_info_object
+        @module_version.nil? ? module_name : "@{ModuleName='#{module_name}';ModuleVersion='#{@module_version}'}"
+      end
+
       def invoke_resource(method, output_format = :object)
-        properties = translate_type(@new_resource.properties)
-        switches = "-Method #{method} -Name #{@new_resource.resource}"\
-                   " -Property #{properties} -Module #{module_name} -Verbose"
+        properties = translate_type(new_resource.properties)
+        switches = "-Method #{method} -Name #{new_resource.resource}"\
+                   " -Property #{properties} -Module #{module_info_object} -Verbose"
         cmdlet = Chef::Util::Powershell::Cmdlet.new(
           node,
           "Invoke-DscResource #{switches}",
@@ -172,15 +188,15 @@ class Chef
 
       def create_reboot_resource
         @reboot_resource = Chef::Resource::Reboot.new(
-          "Reboot for #{@new_resource.name}",
+          "Reboot for #{new_resource.name}",
           run_context
         ).tap do |r|
-          r.reason("Reboot for #{@new_resource.resource}.")
+          r.reason("Reboot for #{new_resource.resource}.")
         end
       end
 
       def reboot_if_required
-        reboot_action = @new_resource.reboot_action
+        reboot_action = new_resource.reboot_action
         unless @reboot_resource.nil?
           case reboot_action
           when :nothing

data/lib/chef/provider/env.rb

@@ -34,17 +34,17 @@ class Chef
       end
 
       def load_current_resource
-        @current_resource = Chef::Resource::Env.new(@new_resource.name)
-        @current_resource.key_name(@new_resource.key_name)
+        @current_resource = Chef::Resource::Env.new(new_resource.name)
+        current_resource.key_name(new_resource.key_name)
 
-        if env_key_exists(@new_resource.key_name)
-          @current_resource.value(env_value(@new_resource.key_name))
+        if env_key_exists(new_resource.key_name)
+          current_resource.value(env_value(new_resource.key_name))
         else
           @key_exists = false
-          Chef::Log.debug("#{@new_resource} key does not exist")
+          Chef::Log.debug("#{new_resource} key does not exist")
         end
 
-        @current_resource
+        current_resource
       end
 
       def env_value(key_name)
@@ -61,7 +61,7 @@ class Chef
       # <true>:: If a change is required
       # <false>:: If a change is not required
       def requires_modify_or_create?
-        if @new_resource.delim
+        if new_resource.delim
           #e.g. check for existing value within PATH
           new_values.inject(0) do |index, val|
             next_index = current_values.find_index val
@@ -70,7 +70,7 @@ class Chef
           end
           false
         else
-          @new_resource.value != @current_resource.value
+          new_resource.value != current_resource.value
         end
       end
 
@@ -80,13 +80,13 @@ class Chef
         if @key_exists
           if requires_modify_or_create?
             modify_env
-            Chef::Log.info("#{@new_resource} altered")
-            @new_resource.updated_by_last_action(true)
+            Chef::Log.info("#{new_resource} altered")
+            new_resource.updated_by_last_action(true)
           end
         else
           create_env
-          Chef::Log.info("#{@new_resource} created")
-          @new_resource.updated_by_last_action(true)
+          Chef::Log.info("#{new_resource} created")
+          new_resource.updated_by_last_action(true)
         end
       end
 
@@ -97,24 +97,24 @@ class Chef
       # <false>:: Caller should delete the key, either no :delim was specific or value was empty
       #           after we removed the element.
       def delete_element
-        return false unless @new_resource.delim #no delim: delete the key
+        return false unless new_resource.delim #no delim: delete the key
         needs_delete = new_values.any? { |v| current_values.include?(v) }
         if !needs_delete
-          Chef::Log.debug("#{@new_resource} element '#{@new_resource.value}' does not exist")
+          Chef::Log.debug("#{new_resource} element '#{new_resource.value}' does not exist")
           return true #do not delete the key
         else
           new_value =
             current_values.select do |item|
               not new_values.include?(item)
-            end.join(@new_resource.delim)
+            end.join(new_resource.delim)
 
           if new_value.empty?
             return false #nothing left here, delete the key
           else
-            old_value = @new_resource.value(new_value)
+            old_value = new_resource.value(new_value)
             create_env
-            Chef::Log.debug("#{@new_resource} deleted #{old_value} element")
-            @new_resource.updated_by_last_action(true)
+            Chef::Log.debug("#{new_resource} deleted #{old_value} element")
+            new_resource.updated_by_last_action(true)
             return true #we removed the element and updated; do not delete the key
           end
         end
@@ -123,8 +123,8 @@ class Chef
       def action_delete
         if @key_exists && !delete_element
           delete_env
-          Chef::Log.info("#{@new_resource} deleted")
-          @new_resource.updated_by_last_action(true)
+          Chef::Log.info("#{new_resource} deleted")
+          new_resource.updated_by_last_action(true)
         end
       end
 
@@ -132,16 +132,16 @@ class Chef
         if @key_exists
           if requires_modify_or_create?
             modify_env
-            Chef::Log.info("#{@new_resource} modified")
-            @new_resource.updated_by_last_action(true)
+            Chef::Log.info("#{new_resource} modified")
+            new_resource.updated_by_last_action(true)
           end
         else
-          raise Chef::Exceptions::Env, "Cannot modify #{@new_resource} - key does not exist!"
+          raise Chef::Exceptions::Env, "Cannot modify #{new_resource} - key does not exist!"
         end
       end
 
       def create_env
-        raise Chef::Exceptions::UnsupportedAction, "#{self} does not support :#{@new_resource.action}"
+        raise Chef::Exceptions::UnsupportedAction, "#{self} does not support :#{new_resource.action}"
       end
 
       def delete_env
@@ -149,20 +149,20 @@ class Chef
       end
 
       def modify_env
-        if @new_resource.delim
-          @new_resource.value((new_values + current_values).uniq.join(@new_resource.delim))
+        if new_resource.delim
+          new_resource.value((new_values + current_values).uniq.join(new_resource.delim))
         end
         create_env
       end
 
       # Returns the current values to split by delimiter
       def current_values
-        @current_values ||= @current_resource.value.split(@new_resource.delim)
+        @current_values ||= current_resource.value.split(new_resource.delim)
       end
 
       # Returns the new values to split by delimiter
       def new_values
-        @new_values ||= @new_resource.value.split(@new_resource.delim)
+        @new_values ||= new_resource.value.split(new_resource.delim)
       end
     end
   end

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

@@ -54,7 +54,7 @@ class Chef
 
         def env_value(key_name)
           obj = env_obj(key_name)
-          return obj ? obj.variablevalue : ENV[key_name]
+          obj ? obj.variablevalue : ENV[key_name]
         end
 
         def env_obj(key_name)

data/lib/chef/provider/erl_call.rb

@@ -40,20 +40,20 @@ class Chef
       end
 
       def action_run
-        case @new_resource.name_type
+        case new_resource.name_type
         when "sname"
-          node = "-sname #{@new_resource.node_name}"
+          node = "-sname #{new_resource.node_name}"
         when "name"
-          node = "-name #{@new_resource.node_name}"
+          node = "-name #{new_resource.node_name}"
         end
 
-        if @new_resource.cookie
-          cookie = "-c #{@new_resource.cookie}"
+        if new_resource.cookie
+          cookie = "-c #{new_resource.cookie}"
         else
           cookie = ""
         end
 
-        if @new_resource.distributed
+        if new_resource.distributed
           distributed = "-s"
         else
           distributed = ""
@@ -65,15 +65,15 @@ class Chef
           begin
             pid, stdin, stdout, stderr = popen4(command, :waitlast => true)
 
-            Chef::Log.debug("#{@new_resource} running")
-            Chef::Log.debug("#{@new_resource} command: #{command}")
-            Chef::Log.debug("#{@new_resource} code: #{@new_resource.code}")
+            Chef::Log.debug("#{new_resource} running")
+            Chef::Log.debug("#{new_resource} command: #{command}")
+            Chef::Log.debug("#{new_resource} code: #{new_resource.code}")
 
-            @new_resource.code.each_line { |line| stdin.puts(line.chomp) }
+            new_resource.code.each_line { |line| stdin.puts(line.chomp) }
 
             stdin.close
 
-            Chef::Log.debug("#{@new_resource} output: ")
+            Chef::Log.debug("#{new_resource} output: ")
 
             stdout_output = ""
             stdout.each_line { |line| stdout_output << line }
@@ -93,9 +93,9 @@ class Chef
               raise Chef::Exceptions::ErlCall, stdout_output
             end
 
-            @new_resource.updated_by_last_action(true)
+            new_resource.updated_by_last_action(true)
 
-            Chef::Log.debug("#{@new_resource} #{stdout_output}")
+            Chef::Log.debug("#{new_resource} #{stdout_output}")
             Chef::Log.info("#{@new_resouce} ran successfully")
           ensure
             Process.wait(pid) if pid

data/lib/chef/provider/execute.rb

@@ -27,7 +27,7 @@ class Chef
 
       provides :execute
 
-      def_delegators :@new_resource, :command, :returns, :environment, :user, :group, :cwd, :umask, :creates
+      def_delegators :new_resource, :command, :returns, :environment, :user, :domain, :password, :group, :cwd, :umask, :creates
 
       def load_current_resource
         current_resource = Chef::Resource::Execute.new(new_resource.name)
@@ -39,7 +39,7 @@ class Chef
       end
 
       def define_resource_requirements
-         # @todo: this should change to raise in some appropriate major version bump.
+        # @todo: this should change to raise in some appropriate major version bump.
         if creates && creates_relative? && !cwd
           Chef::Log.warn "Providing a relative path for the creates attribute without the cwd is deprecated and will be changed to fail in the future (CHEF-3819)"
         end
@@ -92,6 +92,8 @@ class Chef
         opts[:returns]     = returns if returns
         opts[:environment] = environment if environment
         opts[:user]        = user if user
+        opts[:domain]      = domain if domain
+        opts[:password]    = password if password
         opts[:group]       = group if group
         opts[:cwd]         = cwd if cwd
         opts[:umask]       = umask if umask
@@ -120,6 +122,7 @@ class Chef
            ( cwd && creates_relative? ) ? ::File.join(cwd, creates) : creates
         ))
       end
+
     end
   end
 end