chef 12.18.31 → 13.0.118

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

@@ -26,6 +26,10 @@ class Chef
 
         provides :env, os: "windows"
 
+        def whyrun_supported?
+          false
+        end
+
         def create_env
           obj = env_obj(@new_resource.key_name)
           unless obj
@@ -54,7 +58,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/env.rb

@@ -17,34 +17,36 @@
 #
 
 require "chef/provider"
-require "chef/mixin/command"
 require "chef/resource/env"
 
 class Chef
   class Provider
     class Env < Chef::Provider
-      include Chef::Mixin::Command
       attr_accessor :key_exists
 
       provides :env, os: "!windows"
 
+      def whyrun_supported?
+        false
+      end
+
       def initialize(new_resource, run_context)
         super
         @key_exists = true
       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 +63,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 +72,7 @@ class Chef
           end
           false
         else
-          @new_resource.value != @current_resource.value
+          new_resource.value != current_resource.value
         end
       end
 
@@ -80,13 +82,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 +99,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 +125,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 +134,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 +151,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/erl_call.rb

@@ -17,13 +17,11 @@
 #
 
 require "chef/log"
-require "chef/mixin/command"
 require "chef/provider"
 
 class Chef
   class Provider
     class ErlCall < Chef::Provider
-      include Chef::Mixin::Command
 
       provides :erl_call
 
@@ -31,29 +29,25 @@ class Chef
         super(node, new_resource)
       end
 
-      def whyrun_supported?
-        true
-      end
-
       def load_current_resource
         true
       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 = ""
@@ -62,44 +56,18 @@ class Chef
         command = "erl_call -e #{distributed} #{node} #{cookie}"
 
         converge_by("run erlang block") do
-          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}")
-
-            @new_resource.code.each_line { |line| stdin.puts(line.chomp) }
-
-            stdin.close
-
-            Chef::Log.debug("#{@new_resource} output: ")
+          so = shell_out!(command, input: new_resource.code)
 
-            stdout_output = ""
-            stdout.each_line { |line| stdout_output << line }
-            stdout.close
-
-            stderr_output = ""
-            stderr.each_line { |line| stderr_output << line }
-            stderr.close
-
-            # fail if stderr contains anything
-            if stderr_output.length > 0
-              raise Chef::Exceptions::ErlCall, stderr_output
-            end
-
-            # fail if the first 4 characters aren't "{ok,"
-            unless stdout_output[0..3].include?("{ok,")
-              raise Chef::Exceptions::ErlCall, stdout_output
-            end
-
-            @new_resource.updated_by_last_action(true)
+          # fail if stderr contains anything
+          if so.stderr.length > 0
+            raise Chef::Exceptions::ErlCall, so.stderr
+          end
 
-            Chef::Log.debug("#{@new_resource} #{stdout_output}")
-            Chef::Log.info("#{@new_resouce} ran successfully")
-          ensure
-            Process.wait(pid) if pid
+          # fail if the first 4 characters aren't "{ok,"
+          unless so.stdout[0..3].include?("{ok,")
+            raise Chef::Exceptions::ErlCall, so.stdout
           end
+
         end
       end
 

data/lib/chef/provider/execute.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -27,21 +27,17 @@ 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)
         current_resource
       end
 
-      def whyrun_supported?
-        true
-      end
-
       def define_resource_requirements
-         # @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)"
+          # FIXME? move this onto the resource?
+          raise Chef::Exceptions::Execute, "Please either specify a full path for the creates attribute, or specify a cwd propoerty to the #{new_resource} resource"
         end
       end
 
@@ -92,6 +88,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 +118,7 @@ class Chef
            ( cwd && creates_relative? ) ? ::File.join(cwd, creates) : creates
         ))
       end
+
     end
   end
 end

data/lib/chef/provider/file.rb

@@ -1,7 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: Lamont Granquist (<lamont@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software, Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -30,8 +30,6 @@ require "chef/mixin/enforce_ownership_and_permissions"
 require "chef/util/backup"
 require "chef/util/diff"
 require "chef/util/selinux"
-require "chef/deprecation/provider/file"
-require "chef/deprecation/warnings"
 require "chef/file_content_management/deploy"
 
 # The Tao of File Providers:
@@ -52,10 +50,6 @@ class Chef
       include Chef::Util::Selinux
       include Chef::Mixin::FileClass
 
-      extend Chef::Deprecation::Warnings
-      include Chef::Deprecation::Provider::File
-      add_deprecation_warnings_for(Chef::Deprecation::Provider::File.instance_methods)
-
       provides :file
 
       attr_reader :deployment_strategy
@@ -72,10 +66,6 @@ class Chef
         super
       end
 
-      def whyrun_supported?
-        true
-      end
-
       def load_current_resource
         # true if there is a symlink and we need to manage what it points at
         @managing_symlink = file_class.symlink?(new_resource.path) && ( new_resource.manage_symlink_source || new_resource.manage_symlink_source.nil? )
@@ -95,7 +85,7 @@ class Chef
         # true if we are going to be creating a new file
         @needs_creating  = !::File.exist?(new_resource.path) || needs_unlinking?
 
-        # Let children resources override constructing the @current_resource
+        # Let children resources override constructing the current_resource
         @current_resource ||= Chef::Resource::File.new(new_resource.name)
         current_resource.path(new_resource.path)
 
@@ -120,17 +110,17 @@ class Chef
 
         # Make sure the parent directory exists, otherwise fail.  For why-run assume it would have been created.
         requirements.assert(:create, :create_if_missing, :touch) do |a|
-          parent_directory = ::File.dirname(@new_resource.path)
+          parent_directory = ::File.dirname(new_resource.path)
           a.assertion { ::File.directory?(parent_directory) }
           a.failure_message(Chef::Exceptions::EnclosingDirectoryDoesNotExist, "Parent directory #{parent_directory} does not exist.")
           a.whyrun("Assuming directory #{parent_directory} would have been created")
         end
 
         # Make sure the file is deletable if it exists, otherwise fail.
-        if ::File.exist?(@new_resource.path)
+        if ::File.exist?(new_resource.path)
           requirements.assert(:delete) do |a|
-            a.assertion { ::File.writable?(@new_resource.path) }
-            a.failure_message(Chef::Exceptions::InsufficientPermissions, "File #{@new_resource.path} exists but is not writable so it cannot be deleted")
+            a.assertion { ::File.writable?(new_resource.path) }
+            a.failure_message(Chef::Exceptions::InsufficientPermissions, "File #{new_resource.path} exists but is not writable so it cannot be deleted")
           end
         end
 
@@ -154,33 +144,33 @@ class Chef
         do_contents_changes
         do_acl_changes
         do_selinux
-        load_resource_attributes_from_file(@new_resource)
+        load_resource_attributes_from_file(new_resource) unless Chef::Config[:why_run]
       end
 
       def action_create_if_missing
-        unless ::File.exist?(@new_resource.path)
+        unless ::File.exist?(new_resource.path)
           action_create
         else
-          Chef::Log.debug("#{@new_resource} exists at #{@new_resource.path} taking no action.")
+          Chef::Log.debug("#{new_resource} exists at #{new_resource.path} taking no action.")
         end
       end
 
       def action_delete
-        if ::File.exists?(@new_resource.path)
-          converge_by("delete file #{@new_resource.path}") do
-            do_backup unless file_class.symlink?(@new_resource.path)
-            ::File.delete(@new_resource.path)
-            Chef::Log.info("#{@new_resource} deleted file at #{@new_resource.path}")
+        if ::File.exists?(new_resource.path)
+          converge_by("delete file #{new_resource.path}") do
+            do_backup unless file_class.symlink?(new_resource.path)
+            ::File.delete(new_resource.path)
+            Chef::Log.info("#{new_resource} deleted file at #{new_resource.path}")
           end
         end
       end
 
       def action_touch
         action_create
-        converge_by("update utime on file #{@new_resource.path}") do
+        converge_by("update utime on file #{new_resource.path}") do
           time = Time.now
-          ::File.utime(time, time, @new_resource.path)
-          Chef::Log.info("#{@new_resource} updated atime and mtime to #{time}")
+          ::File.utime(time, time, new_resource.path)
+          Chef::Log.info("#{new_resource} updated atime and mtime to #{time}")
         end
       end
 
@@ -197,8 +187,8 @@ class Chef
       # content (for things like doing checksums in load_current_resource).  Expected to
       # be overridden in subclasses.
       def managing_content?
-        return true if @new_resource.checksum
-        return true if !@new_resource.content.nil? && @action != :create_if_missing
+        return true if new_resource.checksum
+        return true if !new_resource.content.nil? && @action != :create_if_missing
         false
       end
 
@@ -228,25 +218,25 @@ class Chef
       # assertions, which then decide whether or not to raise or issue a
       # warning for whyrun mode.
       def inspect_existing_fs_entry
-        path = @new_resource.path
+        path = new_resource.path
 
         if !l_exist?(path)
           [nil, nil, nil]
         elsif real_file?(path)
           [nil, nil, nil]
-        elsif file_class.symlink?(path) && @new_resource.manage_symlink_source
+        elsif file_class.symlink?(path) && new_resource.manage_symlink_source
           verify_symlink_sanity(path)
-        elsif file_class.symlink?(@new_resource.path) && @new_resource.manage_symlink_source.nil?
-          Chef::Log.warn("File #{path} managed by #{@new_resource} is really a symlink. Managing the source file instead.")
+        elsif file_class.symlink?(new_resource.path) && new_resource.manage_symlink_source.nil?
+          Chef::Log.warn("File #{path} managed by #{new_resource} is really a symlink. Managing the source file instead.")
           Chef::Log.warn("Disable this warning by setting `manage_symlink_source true` on the resource")
           Chef::Log.warn("In a future Chef release, 'manage_symlink_source' will not be enabled by default")
           verify_symlink_sanity(path)
-        elsif @new_resource.force_unlink
+        elsif new_resource.force_unlink
           [nil, nil, nil]
         else
           [ Chef::Exceptions::FileTypeMismatch,
-            "File #{path} exists, but is a #{file_type_string(@new_resource.path)}, set force_unlink to true to remove",
-            "Assuming #{file_type_string(@new_resource.path)} at #{@new_resource.path} would have been removed by a previous resource",
+            "File #{path} exists, but is a #{file_type_string(new_resource.path)}, set force_unlink to true to remove",
+            "Assuming #{file_type_string(new_resource.path)} at #{new_resource.path} would have been removed by a previous resource",
           ]
         end
       end
@@ -282,8 +272,8 @@ class Chef
 
       def content
         @content ||= begin
-          load_current_resource if @current_resource.nil?
-          @content_class.new(@new_resource, @current_resource, @run_context)
+          load_current_resource if current_resource.nil?
+          @content_class.new(new_resource, current_resource, @run_context)
         end
       end
 
@@ -312,11 +302,9 @@ class Chef
 
       # like real_file? that follows (sane) symlinks
       def symlink_to_real_file?(path)
-        begin
-          real_file?(::File.realpath(path))
-        rescue Errno::ELOOP, Errno::ENOENT
-          false
-        end
+        real_file?(::File.realpath(path))
+      rescue Errno::ELOOP, Errno::ENOENT
+        false
       end
 
       # Similar to File.exist?, but also returns true in the case that the
@@ -358,12 +346,12 @@ class Chef
       end
 
       def do_unlink
-        if @new_resource.force_unlink
+        if new_resource.force_unlink
           if needs_unlinking?
             # unlink things that aren't normal files
-            description = "unlink #{file_type_string(@new_resource.path)} at #{@new_resource.path}"
+            description = "unlink #{file_type_string(new_resource.path)} at #{new_resource.path}"
             converge_by(description) do
-              unlink(@new_resource.path)
+              unlink(new_resource.path)
             end
           end
         end
@@ -371,15 +359,15 @@ class Chef
 
       def do_create_file
         if needs_creating?
-          converge_by("create new file #{@new_resource.path}") do
-            deployment_strategy.create(@new_resource.path)
-            Chef::Log.info("#{@new_resource} created file #{@new_resource.path}")
+          converge_by("create new file #{new_resource.path}") do
+            deployment_strategy.create(new_resource.path)
+            Chef::Log.info("#{new_resource} created file #{new_resource.path}")
           end
         end
       end
 
       def do_backup(file = nil)
-        Chef::Util::Backup.new(@new_resource, file).backup!
+        Chef::Util::Backup.new(new_resource, file).backup!
       end
 
       def diff
@@ -405,17 +393,17 @@ class Chef
         end
 
         # the file? on the next line suppresses the case in why-run when we have a not-file here that would have otherwise been removed
-        if ::File.file?(@new_resource.path) && contents_changed?
-          description = [ "update content in file #{@new_resource.path} from \
-#{short_cksum(@current_resource.checksum)} to #{short_cksum(tempfile_checksum)}" ]
+        if ::File.file?(new_resource.path) && contents_changed?
+          description = [ "update content in file #{new_resource.path} from \
+#{short_cksum(current_resource.checksum)} to #{short_cksum(tempfile_checksum)}" ]
 
           # Hide the diff output if the resource is marked as a sensitive resource
-          if @new_resource.sensitive
-            @new_resource.diff("suppressed sensitive resource")
+          if new_resource.sensitive
+            new_resource.diff("suppressed sensitive resource")
             description << "suppressed sensitive resource"
           else
-            diff.diff(@current_resource.path, tempfile.path)
-            @new_resource.diff( diff.for_reporting ) unless needs_creating?
+            diff.diff(current_resource.path, tempfile.path)
+            new_resource.diff( diff.for_reporting ) unless needs_creating?
             description << diff.for_output
           end
 
@@ -437,7 +425,7 @@ class Chef
         if resource_updated? && Chef::Config[:enable_selinux_file_permission_fixup]
           if selinux_enabled?
             converge_by("restore selinux security context") do
-              restore_security_context(::File.realpath(@new_resource.path), recursive)
+              restore_security_context(::File.realpath(new_resource.path), recursive)
             end
           else
             Chef::Log.debug "selinux utilities can not be found. Skipping selinux permission fixup."
@@ -454,8 +442,8 @@ class Chef
       end
 
       def contents_changed?
-        Chef::Log.debug "calculating checksum of #{tempfile.path} to compare with #{@current_resource.checksum}"
-        tempfile_checksum != @current_resource.checksum
+        Chef::Log.debug "calculating checksum of #{tempfile.path} to compare with #{current_resource.checksum}"
+        tempfile_checksum != current_resource.checksum
       end
 
       def tempfile
@@ -470,7 +458,7 @@ class Chef
           # reporting won't work for Windows.
           return
         end
-        acl_scanner = ScanAccessControl.new(@new_resource, resource)
+        acl_scanner = ScanAccessControl.new(new_resource, resource)
         acl_scanner.set_all!
       end