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

data/lib/chef/provider/registry_key.rb

@@ -2,7 +2,7 @@
 # Author:: Prajakta Purohit (<prajakta@chef.io>)
 # Author:: Lamont Granquist (<lamont@chef.io>)
 #
-# Copyright:: Copyright 2011-2016, Chef Software Inc.
+# Copyright:: Copyright 2011-2017, Chef Software Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -47,19 +47,19 @@ class Chef
 
       def load_current_resource
         running_on_windows!
-        @current_resource ||= Chef::Resource::RegistryKey.new(@new_resource.key, run_context)
-        @current_resource.key(@new_resource.key)
-        @current_resource.architecture(@new_resource.architecture)
-        @current_resource.recursive(@new_resource.recursive)
-        if registry.key_exists?(@new_resource.key)
-          @current_resource.values(registry.get_values(@new_resource.key))
-        end
-        values_to_hash(@current_resource.unscrubbed_values)
-        @current_resource
+        @current_resource ||= Chef::Resource::RegistryKey.new(new_resource.key, run_context)
+        current_resource.key(new_resource.key)
+        current_resource.architecture(new_resource.architecture)
+        current_resource.recursive(new_resource.recursive)
+        if registry.key_exists?(new_resource.key)
+          current_resource.values(registry.get_values(new_resource.key))
+        end
+        values_to_hash(current_resource.unscrubbed_values)
+        current_resource
       end
 
       def registry
-        @registry ||= Chef::Win32::Registry.new(@run_context, @new_resource.architecture)
+        @registry ||= Chef::Win32::Registry.new(@run_context, new_resource.architecture)
       end
 
       def values_to_hash(values)
@@ -79,51 +79,51 @@ class Chef
 
       def define_resource_requirements
         requirements.assert(:create, :create_if_missing, :delete, :delete_key) do |a|
-          a.assertion { registry.hive_exists?(@new_resource.key) }
-          a.failure_message(Chef::Exceptions::Win32RegHiveMissing, "Hive #{@new_resource.key.split("\\").shift} does not exist")
+          a.assertion { registry.hive_exists?(new_resource.key) }
+          a.failure_message(Chef::Exceptions::Win32RegHiveMissing, "Hive #{new_resource.key.split("\\").shift} does not exist")
         end
 
         requirements.assert(:create) do |a|
-          a.assertion { registry.key_exists?(@new_resource.key) }
-          a.whyrun("Key #{@new_resource.key} does not exist. Unless it would have been created before, attempt to modify its values would fail.")
+          a.assertion { registry.key_exists?(new_resource.key) }
+          a.whyrun("Key #{new_resource.key} does not exist. Unless it would have been created before, attempt to modify its values would fail.")
         end
 
         requirements.assert(:create, :create_if_missing) do |a|
           # If keys missing in the path and recursive == false
-          a.assertion { !registry.keys_missing?(@current_resource.key) || @new_resource.recursive }
+          a.assertion { !registry.keys_missing?(current_resource.key) || new_resource.recursive }
           a.failure_message(Chef::Exceptions::Win32RegNoRecursive, "Intermediate keys missing but recursive is set to false")
-          a.whyrun("Intermediate keys in #{@new_resource.key} do not exist. Unless they would have been created earlier, attempt to modify them would fail.")
+          a.whyrun("Intermediate keys in #{new_resource.key} do not exist. Unless they would have been created earlier, attempt to modify them would fail.")
         end
 
         requirements.assert(:delete_key) do |a|
           # If key to be deleted has subkeys but recurssive == false
-          a.assertion { !registry.key_exists?(@new_resource.key) || !registry.has_subkeys?(@new_resource.key) || @new_resource.recursive }
-          a.failure_message(Chef::Exceptions::Win32RegNoRecursive, "#{@new_resource.key} has subkeys but recursive is set to false.")
-          a.whyrun("#{@current_resource.key} has subkeys, but recursive is set to false. attempt to delete would fails unless subkeys were deleted prior to this action.")
+          a.assertion { !registry.key_exists?(new_resource.key) || !registry.has_subkeys?(new_resource.key) || new_resource.recursive }
+          a.failure_message(Chef::Exceptions::Win32RegNoRecursive, "#{new_resource.key} has subkeys but recursive is set to false.")
+          a.whyrun("#{current_resource.key} has subkeys, but recursive is set to false. attempt to delete would fails unless subkeys were deleted prior to this action.")
         end
 
         requirements.assert(:create, :create_if_missing) do |a|
           # If type key missing in the RegistryKey values hash
-          a.assertion { !key_missing?(@new_resource.values, :type) }
+          a.assertion { !key_missing?(new_resource.values, :type) }
           a.failure_message(Chef::Exceptions::RegKeyValuesTypeMissing, "Missing type key in RegistryKey values hash")
           a.whyrun("Type key does not exist. Attempt would fail unless the complete values hash containing all the keys does not exist for registry_key resource's create action.")
         end
 
         requirements.assert(:create, :create_if_missing) do |a|
           # If data key missing in the RegistryKey values hash
-          a.assertion { !key_missing?(@new_resource.values, :data) }
+          a.assertion { !key_missing?(new_resource.values, :data) }
           a.failure_message(Chef::Exceptions::RegKeyValuesDataMissing, "Missing data key in RegistryKey values hash")
           a.whyrun("Data key does not exist. Attempt would fail unless the complete values hash containing all the keys does not exist for registry_key resource's create action.")
         end
       end
 
       def action_create
-        unless registry.key_exists?(@current_resource.key)
-          converge_by("create key #{@new_resource.key}") do
-            registry.create_key(@new_resource.key, @new_resource.recursive)
+        unless registry.key_exists?(current_resource.key)
+          converge_by("create key #{new_resource.key}") do
+            registry.create_key(new_resource.key, new_resource.recursive)
           end
         end
-        @new_resource.unscrubbed_values.each do |value|
+        new_resource.unscrubbed_values.each do |value|
           if @name_hash.has_key?(value[:name].downcase)
             current_value = @name_hash[value[:name].downcase]
             if [:dword, :dword_big_endian, :qword].include? value[:type]
@@ -131,38 +131,38 @@ class Chef
             end
             unless current_value[:type] == value[:type] && current_value[:data] == value[:data]
               converge_by("set value #{value}") do
-                registry.set_value(@new_resource.key, value)
+                registry.set_value(new_resource.key, value)
               end
             end
           else
             converge_by("set value #{value}") do
-              registry.set_value(@new_resource.key, value)
+              registry.set_value(new_resource.key, value)
             end
           end
         end
       end
 
       def action_create_if_missing
-        unless registry.key_exists?(@new_resource.key)
-          converge_by("create key #{@new_resource.key}") do
-            registry.create_key(@new_resource.key, @new_resource.recursive)
+        unless registry.key_exists?(new_resource.key)
+          converge_by("create key #{new_resource.key}") do
+            registry.create_key(new_resource.key, new_resource.recursive)
           end
         end
-        @new_resource.unscrubbed_values.each do |value|
+        new_resource.unscrubbed_values.each do |value|
           unless @name_hash.has_key?(value[:name].downcase)
             converge_by("create value #{value}") do
-              registry.set_value(@new_resource.key, value)
+              registry.set_value(new_resource.key, value)
             end
           end
         end
       end
 
       def action_delete
-        if registry.key_exists?(@new_resource.key)
-          @new_resource.unscrubbed_values.each do |value|
+        if registry.key_exists?(new_resource.key)
+          new_resource.unscrubbed_values.each do |value|
             if @name_hash.has_key?(value[:name].downcase)
               converge_by("delete value #{value}") do
-                registry.delete_value(@new_resource.key, value)
+                registry.delete_value(new_resource.key, value)
               end
             end
           end
@@ -170,9 +170,9 @@ class Chef
       end
 
       def action_delete_key
-        if registry.key_exists?(@new_resource.key)
-          converge_by("delete key #{@new_resource.key}") do
-            registry.delete_key(@new_resource.key, @new_resource.recursive)
+        if registry.key_exists?(new_resource.key)
+          converge_by("delete key #{new_resource.key}") do
+            registry.delete_key(new_resource.key, new_resource.recursive)
           end
         end
       end

data/lib/chef/provider/remote_directory.rb

@@ -36,9 +36,9 @@ class Chef
 
       provides :remote_directory
 
-      def_delegators :@new_resource, :purge, :path, :source, :cookbook, :cookbook_name
-      def_delegators :@new_resource, :files_rights, :files_mode, :files_group, :files_owner, :files_backup
-      def_delegators :@new_resource, :rights, :mode, :group, :owner
+      def_delegators :new_resource, :purge, :path, :source, :cookbook, :cookbook_name
+      def_delegators :new_resource, :files_rights, :files_mode, :files_group, :files_owner, :files_backup
+      def_delegators :new_resource, :rights, :mode, :group, :owner
 
       # The overwrite property on the resource.  Delegates to new_resource but can be mutated.
       #

data/lib/chef/provider/remote_file.rb

@@ -36,15 +36,15 @@ class Chef
       end
 
       def load_current_resource
-        @current_resource = Chef::Resource::RemoteFile.new(@new_resource.name)
+        @current_resource = Chef::Resource::RemoteFile.new(new_resource.name)
         super
       end
 
       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/route.rb

@@ -219,7 +219,7 @@ class Chef
         case action
         when :add
           content << (options[:target]).to_s
-          content << "/#{options[:netmask]}" if options[:netmask]
+          content << "/#{MASK[options[:netmask].to_s]}" if options[:netmask]
           content << " via #{options[:gateway]}" if options[:gateway]
           content << "\n"
         end

data/lib/chef/provider/ruby_block.rb

@@ -31,9 +31,9 @@ class Chef
       end
 
       def action_run
-        converge_by("execute the ruby block #{@new_resource.name}") do
-          @new_resource.block.call
-          Chef::Log.info("#{@new_resource} called")
+        converge_by("execute the ruby block #{new_resource.name}") do
+          new_resource.block.call
+          Chef::Log.info("#{new_resource} called")
         end
       end
 

data/lib/chef/provider/script.rb

@@ -18,6 +18,7 @@
 
 require "tempfile"
 require "chef/provider/execute"
+require "chef/win32/security" if Chef::Platform.windows?
 require "forwardable"
 
 class Chef
@@ -33,7 +34,7 @@ class Chef
       provides :ruby
       provides :script
 
-      def_delegators :@new_resource, :interpreter, :flags
+      def_delegators :new_resource, :interpreter, :flags
 
       attr_accessor :code
 
@@ -50,7 +51,7 @@ class Chef
         super
         # @todo Chef-13: change this to an exception
         if code.nil?
-          Chef::Log.warn "#{@new_resource}: No code attribute was given, resource does nothing, this behavior is deprecated and will be removed in Chef-13"
+          Chef::Log.warn "#{new_resource}: No code attribute was given, resource does nothing, this behavior is deprecated and will be removed in Chef-13"
         end
       end
 
@@ -66,10 +67,45 @@ class Chef
       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)
+        if Chef::Platform.windows?
+          # And on Windows also this is a no-op if there is no user specified.
+          grant_alternate_user_read_access
+        else
+          # 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
+      end
+
+      def grant_alternate_user_read_access
+        # Do nothing if an alternate user isn't specified -- the file
+        # will already have the correct permissions for the user as part
+        # of the default ACL behavior on Windows.
+        return if new_resource.user.nil?
+
+        # Duplicate the script file's existing DACL
+        # so we can add an ACE later
+        securable_object = Chef::ReservedNames::Win32::Security::SecurableObject.new(script_file.path)
+        aces = securable_object.security_descriptor.dacl.reduce([]) { |result, current| result.push(current) }
+
+        username = new_resource.user
+
+        if new_resource.domain
+          username = new_resource.domain + '\\' + new_resource.user
+        end
+
+        # Create an ACE that allows the alternate user read access to the script
+        # file so it can be read and executed.
+        user_sid = Chef::ReservedNames::Win32::Security::SID.from_account(username)
+        read_ace = Chef::ReservedNames::Win32::Security::ACE.access_allowed(user_sid, Chef::ReservedNames::Win32::API::Security::GENERIC_READ | Chef::ReservedNames::Win32::API::Security::GENERIC_EXECUTE, 0)
+        aces.push(read_ace)
+        acl = Chef::ReservedNames::Win32::Security::ACL.create(aces)
+
+        # This actually applies the modified DACL to the file
+        # Use parentheses to bypass RuboCop / ChefStyle warning
+        # about useless setter
+        (securable_object.dacl = acl)
       end
 
       def script_file

data/lib/chef/provider/service.rb

@@ -51,21 +51,21 @@ class Chef
       # XXX?: the #nil? check below will likely fail if this is a cloned resource or if
       # we just run multiple actions.
       def load_new_resource_state
-        if @new_resource.enabled.nil?
-          @new_resource.enabled(@current_resource.enabled)
+        if new_resource.enabled.nil?
+          new_resource.enabled(current_resource.enabled)
         end
-        if @new_resource.running.nil?
-          @new_resource.running(@current_resource.running)
+        if new_resource.running.nil?
+          new_resource.running(current_resource.running)
         end
-        if @new_resource.masked.nil?
-          @new_resource.masked(@current_resource.masked)
+        if new_resource.masked.nil?
+          new_resource.masked(current_resource.masked)
         end
       end
 
       # subclasses should override this if they do implement user services
       def user_services_requirements
         requirements.assert(:all_actions) do |a|
-          a.assertion { @new_resource.user.nil? }
+          a.assertion { new_resource.user.nil? }
           a.failure_message Chef::Exceptions::UnsupportedAction, "#{self} does not support user services"
         end
       end
@@ -76,7 +76,7 @@ class Chef
 
       def define_resource_requirements
         requirements.assert(:reload) do |a|
-          a.assertion { supports[:reload] || @new_resource.reload_command }
+          a.assertion { supports[:reload] || new_resource.reload_command }
           a.failure_message Chef::Exceptions::UnsupportedAction, "#{self} does not support :reload"
           # if a service is not declared to support reload, that won't
           # typically change during the course of a run - so no whyrun
@@ -85,97 +85,97 @@ class Chef
       end
 
       def action_enable
-        if @current_resource.enabled
-          Chef::Log.debug("#{@new_resource} already enabled - nothing to do")
+        if current_resource.enabled
+          Chef::Log.debug("#{new_resource} already enabled - nothing to do")
         else
-          converge_by("enable service #{@new_resource}") do
+          converge_by("enable service #{new_resource}") do
             enable_service
-            Chef::Log.info("#{@new_resource} enabled")
+            Chef::Log.info("#{new_resource} enabled")
           end
         end
         load_new_resource_state
-        @new_resource.enabled(true)
+        new_resource.enabled(true)
       end
 
       def action_disable
-        if @current_resource.enabled
-          converge_by("disable service #{@new_resource}") do
+        if current_resource.enabled
+          converge_by("disable service #{new_resource}") do
             disable_service
-            Chef::Log.info("#{@new_resource} disabled")
+            Chef::Log.info("#{new_resource} disabled")
           end
         else
-          Chef::Log.debug("#{@new_resource} already disabled - nothing to do")
+          Chef::Log.debug("#{new_resource} already disabled - nothing to do")
         end
         load_new_resource_state
-        @new_resource.enabled(false)
+        new_resource.enabled(false)
       end
 
       def action_mask
-        if @current_resource.masked
-          Chef::Log.debug("#{@new_resource} already masked - nothing to do")
+        if current_resource.masked
+          Chef::Log.debug("#{new_resource} already masked - nothing to do")
         else
-          converge_by("mask service #{@new_resource}") do
+          converge_by("mask service #{new_resource}") do
             mask_service
-            Chef::Log.info("#{@new_resource} masked")
+            Chef::Log.info("#{new_resource} masked")
           end
         end
         load_new_resource_state
-        @new_resource.masked(true)
+        new_resource.masked(true)
       end
 
       def action_unmask
-        if @current_resource.masked
-          converge_by("unmask service #{@new_resource}") do
+        if current_resource.masked
+          converge_by("unmask service #{new_resource}") do
             unmask_service
-            Chef::Log.info("#{@new_resource} unmasked")
+            Chef::Log.info("#{new_resource} unmasked")
           end
         else
-          Chef::Log.debug("#{@new_resource} already unmasked - nothing to do")
+          Chef::Log.debug("#{new_resource} already unmasked - nothing to do")
         end
         load_new_resource_state
-        @new_resource.masked(false)
+        new_resource.masked(false)
       end
 
       def action_start
-        unless @current_resource.running
-          converge_by("start service #{@new_resource}") do
+        unless current_resource.running
+          converge_by("start service #{new_resource}") do
             start_service
-            Chef::Log.info("#{@new_resource} started")
+            Chef::Log.info("#{new_resource} started")
           end
         else
-          Chef::Log.debug("#{@new_resource} already running - nothing to do")
+          Chef::Log.debug("#{new_resource} already running - nothing to do")
         end
         load_new_resource_state
-        @new_resource.running(true)
+        new_resource.running(true)
       end
 
       def action_stop
-        if @current_resource.running
-          converge_by("stop service #{@new_resource}") do
+        if current_resource.running
+          converge_by("stop service #{new_resource}") do
             stop_service
-            Chef::Log.info("#{@new_resource} stopped")
+            Chef::Log.info("#{new_resource} stopped")
           end
         else
-          Chef::Log.debug("#{@new_resource} already stopped - nothing to do")
+          Chef::Log.debug("#{new_resource} already stopped - nothing to do")
         end
         load_new_resource_state
-        @new_resource.running(false)
+        new_resource.running(false)
       end
 
       def action_restart
-        converge_by("restart service #{@new_resource}") do
+        converge_by("restart service #{new_resource}") do
           restart_service
-          Chef::Log.info("#{@new_resource} restarted")
+          Chef::Log.info("#{new_resource} restarted")
         end
         load_new_resource_state
-        @new_resource.running(true)
+        new_resource.running(true)
       end
 
       def action_reload
-        if @current_resource.running
-          converge_by("reload service #{@new_resource}") do
+        if current_resource.running
+          converge_by("reload service #{new_resource}") do
             reload_service
-            Chef::Log.info("#{@new_resource} reloaded")
+            Chef::Log.info("#{new_resource} reloaded")
           end
         end
         load_new_resource_state
@@ -216,17 +216,17 @@ class Chef
       protected
 
       def default_init_command
-        if @new_resource.init_command
-          @new_resource.init_command
-        elsif self.instance_variable_defined?(:@init_command)
+        if new_resource.init_command
+          new_resource.init_command
+        elsif instance_variable_defined?(:@init_command)
           @init_command
         end
       end
 
       def custom_command_for_action?(action)
         method_name = "#{action}_command".to_sym
-        @new_resource.respond_to?(method_name) &&
-          !!@new_resource.send(method_name)
+        new_resource.respond_to?(method_name) &&
+          !!new_resource.send(method_name)
       end
 
       module ServicePriorityInit